fix: tm show UI

apps/cli/package.json

@@ -6,15 +6,10 @@
 	"main": "./dist/index.js",
 	"types": "./src/index.ts",
 	"exports": {
-		".": {
+		".": "./src/index.ts"
-			"types": "./src/index.ts",
-			"import": "./dist/index.js"
-		}
 	},
 	"files": ["dist", "README.md"],
 	"scripts": {
-		"build": "tsc",
-		"dev": "tsc --watch",
 		"typecheck": "tsc --noEmit",
 		"lint": "biome check src",
 		"format": "biome format --write src",
@@ -48,5 +43,10 @@
 	},
 	"keywords": ["task-master", "cli", "task-management", "productivity"],
 	"author": "",
-	"license": "MIT"
+	"license": "MIT",
+	"typesVersions": {
+		"*": {
+			"*": ["src/*"]
+		}
+	}
 }

apps/cli/src/commands/list.command.ts

@@ -17,6 +17,18 @@ import {
 } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
+import {
+	displayHeader,
+	displayDashboards,
+	calculateTaskStatistics,
+	calculateSubtaskStatistics,
+	calculateDependencyStatistics,
+	getPriorityBreakdown,
+	displayRecommendedNextTask,
+	getTaskDescription,
+	displaySuggestedNextSteps,
+	type NextTaskInfo
+} from '../ui/index.js';
 
 /**
  * Options interface for the list command
@@ -245,19 +257,16 @@ export class ListTasksCommand extends Command {
 	 * Display in text format with tables
 	 */
 	private displayText(data: ListTasksResult, withSubtasks?: boolean): void {
-		const { tasks, total, filtered, tag, storageType } = data;
+		const { tasks, tag } = data;
 
-		// Header
+		// Get file path for display
-		ui.displayBanner(`Task List${tag ? ` (${tag})` : ''}`);
+		const filePath = this.tmCore ? `.taskmaster/tasks/tasks.json` : undefined;
 
-		// Statistics
+		// Display header without banner (banner already shown by main CLI)
-		console.log(chalk.blue.bold('\n📊 Statistics:\n'));
+		displayHeader({
-		console.log(`  Total tasks: ${chalk.cyan(total)}`);
+			tag: tag || 'master',
-		console.log(`  Filtered: ${chalk.cyan(filtered)}`);
+			filePath: filePath
-		if (tag) {
+		});
-			console.log(`  Tag: ${chalk.cyan(tag)}`);
-		}
-		console.log(`  Storage: ${chalk.cyan(storageType)}`);
 
 		// No tasks message
 		if (tasks.length === 0) {
@@ -265,21 +274,50 @@ export class ListTasksCommand extends Command {
 			return;
 		}
 
-		// Task table
+		// Calculate statistics
-		console.log(chalk.blue.bold(`\n📋 Tasks (${tasks.length}):\n`));
+		const taskStats = calculateTaskStatistics(tasks);
+		const subtaskStats = calculateSubtaskStatistics(tasks);
+		const depStats = calculateDependencyStatistics(tasks);
+		const priorityBreakdown = getPriorityBreakdown(tasks);
+
+		// Find next task following the same logic as findNextTask
+		const nextTask = this.findNextTask(tasks);
+
+		// Display dashboard boxes
+		displayDashboards(
+			taskStats,
+			subtaskStats,
+			priorityBreakdown,
+			depStats,
+			nextTask
+		);
+
+		// Task table - no title, just show the table directly
 		console.log(
 			ui.createTaskTable(tasks, {
 				showSubtasks: withSubtasks,
-				showDependencies: true
+				showDependencies: true,
+				showComplexity: true // Enable complexity column
 			})
 		);
 
-		// Progress bar
+		// Display recommended next task section immediately after table
-		const completedCount = tasks.filter(
+		if (nextTask) {
-			(t: Task) => t.status === 'done'
+			// Find the full task object to get description
-		).length;
+			const fullTask = tasks.find((t) => String(t.id) === String(nextTask.id));
-		console.log(chalk.blue.bold('\n📊 Overall Progress:\n'));
+			const description = fullTask ? getTaskDescription(fullTask) : undefined;
-		console.log(`  ${ui.createProgressBar(completedCount, tasks.length)}`);
+
+			displayRecommendedNextTask({
+				...nextTask,
+				status: 'pending', // Next task is typically pending
+				description
+			});
+		} else {
+			displayRecommendedNextTask(undefined);
+		}
+
+		// Display suggested next steps at the end
+		displaySuggestedNextSteps();
 	}
 
 	/**
@@ -289,6 +327,128 @@ export class ListTasksCommand extends Command {
 		this.lastResult = result;
 	}
 
+	/**
+	 * Find the next task to work on
+	 * Implements the same logic as scripts/modules/task-manager/find-next-task.js
+	 */
+	private findNextTask(tasks: Task[]): NextTaskInfo | undefined {
+		const priorityValues: Record<string, number> = {
+			critical: 4,
+			high: 3,
+			medium: 2,
+			low: 1
+		};
+
+		// Build set of completed task IDs (including subtasks)
+		const completedIds = new Set<string>();
+		tasks.forEach((t) => {
+			if (t.status === 'done' || t.status === 'completed') {
+				completedIds.add(String(t.id));
+			}
+			if (t.subtasks) {
+				t.subtasks.forEach((st) => {
+					if (st.status === 'done' || st.status === 'completed') {
+						completedIds.add(`${t.id}.${st.id}`);
+					}
+				});
+			}
+		});
+
+		// First, look for eligible subtasks in in-progress parent tasks
+		const candidateSubtasks: NextTaskInfo[] = [];
+
+		tasks
+			.filter(
+				(t) => t.status === 'in-progress' && t.subtasks && t.subtasks.length > 0
+			)
+			.forEach((parent) => {
+				parent.subtasks!.forEach((st) => {
+					const stStatus = (st.status || 'pending').toLowerCase();
+					if (stStatus !== 'pending' && stStatus !== 'in-progress') return;
+
+					// Check if dependencies are satisfied
+					const fullDeps =
+						st.dependencies?.map((d) => {
+							// Handle both numeric and string IDs
+							if (typeof d === 'string' && d.includes('.')) {
+								return d;
+							}
+							return `${parent.id}.${d}`;
+						}) ?? [];
+
+					const depsSatisfied =
+						fullDeps.length === 0 ||
+						fullDeps.every((depId) => completedIds.has(String(depId)));
+
+					if (depsSatisfied) {
+						candidateSubtasks.push({
+							id: `${parent.id}.${st.id}`,
+							title: st.title || `Subtask ${st.id}`,
+							priority: st.priority || parent.priority || 'medium',
+							dependencies: fullDeps.map((d) => String(d))
+						});
+					}
+				});
+			});
+
+		if (candidateSubtasks.length > 0) {
+			// Sort by priority, then by dependencies count, then by ID
+			candidateSubtasks.sort((a, b) => {
+				const pa = priorityValues[a.priority || 'medium'] ?? 2;
+				const pb = priorityValues[b.priority || 'medium'] ?? 2;
+				if (pb !== pa) return pb - pa;
+
+				const depCountA = a.dependencies?.length || 0;
+				const depCountB = b.dependencies?.length || 0;
+				if (depCountA !== depCountB) return depCountA - depCountB;
+
+				return String(a.id).localeCompare(String(b.id));
+			});
+			return candidateSubtasks[0];
+		}
+
+		// Fall back to finding eligible top-level tasks
+		const eligibleTasks = tasks.filter((task) => {
+			// Skip non-eligible statuses
+			const status = (task.status || 'pending').toLowerCase();
+			if (status !== 'pending' && status !== 'in-progress') return false;
+
+			// Check dependencies
+			const deps = task.dependencies || [];
+			const depsSatisfied =
+				deps.length === 0 ||
+				deps.every((depId) => completedIds.has(String(depId)));
+
+			return depsSatisfied;
+		});
+
+		if (eligibleTasks.length === 0) return undefined;
+
+		// Sort eligible tasks
+		eligibleTasks.sort((a, b) => {
+			// Priority (higher first)
+			const pa = priorityValues[a.priority || 'medium'] ?? 2;
+			const pb = priorityValues[b.priority || 'medium'] ?? 2;
+			if (pb !== pa) return pb - pa;
+
+			// Dependencies count (fewer first)
+			const depCountA = a.dependencies?.length || 0;
+			const depCountB = b.dependencies?.length || 0;
+			if (depCountA !== depCountB) return depCountA - depCountB;
+
+			// ID (lower first)
+			return Number(a.id) - Number(b.id);
+		});
+
+		const nextTask = eligibleTasks[0];
+		return {
+			id: nextTask.id,
+			title: nextTask.title,
+			priority: nextTask.priority,
+			dependencies: nextTask.dependencies?.map((d) => String(d))
+		};
+	}
+
 	/**
 	 * Get the last result (for programmatic usage)
 	 */

apps/cli/src/commands/show.command.ts

@@ -9,6 +9,14 @@ import boxen from 'boxen';
 import { createTaskMasterCore, type Task, type TaskMasterCore } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
+import {
+	displayTaskHeader,
+	displayTaskProperties,
+	displayImplementationDetails,
+	displayTestStrategy,
+	displaySubtasks,
+	displaySuggestedActions
+} from '../ui/components/task-detail.component.js';
 
 /**
  * Options interface for the show command
@@ -258,46 +266,26 @@ export class ShowCommand extends Command {
 
 		const task = result.task;
 
-		// Header
+		// Display header with tag
-		console.log(
+		displayTaskHeader(task.id, task.title);
-			boxen(chalk.white.bold(`Task #${task.id} - ${task.title}`), {
-				padding: { top: 0, bottom: 0, left: 1, right: 1 },
-				borderColor: 'blue',
-				borderStyle: 'round',
-				margin: { top: 1 }
-			})
-		);
 
-		// Task details
+		// Display task properties in table format
-		console.log(
+		displayTaskProperties(task);
-			`\n${chalk.blue.bold('Status:')} ${ui.getStatusWithColor(task.status)}`
-		);
-		console.log(
-			`${chalk.blue.bold('Priority:')} ${ui.getPriorityWithColor(task.priority)}`
-		);
-
-		if (task.description) {
-			console.log(`\n${chalk.blue.bold('Description:')}`);
-			console.log(task.description);
-		}
 
+		// Display implementation details if available
 		if (task.details) {
-			console.log(`\n${chalk.blue.bold('Details:')}`);
+			console.log(); // Empty line for spacing
-			console.log(task.details);
+			displayImplementationDetails(task.details);
 		}
 
-		// Dependencies
+		// Display test strategy if available
-		if (task.dependencies && task.dependencies.length > 0) {
+		if ('testStrategy' in task && task.testStrategy) {
-			console.log(`\n${chalk.blue.bold('Dependencies:')}`);
+			console.log(); // Empty line for spacing
-			task.dependencies.forEach((dep) => {
+			displayTestStrategy(task.testStrategy as string);
-				console.log(`  - ${chalk.cyan(dep)}`);
-			});
 		}
 
-		// Subtasks
+		// Display subtasks if available
 		if (task.subtasks && task.subtasks.length > 0) {
-			console.log(`\n${chalk.blue.bold('Subtasks:')}`);
-
 			// Filter subtasks by status if provided
 			const filteredSubtasks = options.status
 				? task.subtasks.filter((sub) => sub.status === options.status)
@@ -308,23 +296,12 @@ export class ShowCommand extends Command {
 					chalk.gray(`  No subtasks with status '${options.status}'`)
 				);
 			} else {
-				filteredSubtasks.forEach((subtask) => {
+				displaySubtasks(filteredSubtasks, task.id);
-					console.log(
-						`  ${chalk.cyan(`${task.id}.${subtask.id}`)} ${ui.getStatusWithColor(subtask.status)} ${subtask.title}`
-					);
-					if (subtask.description) {
-						console.log(`    ${chalk.gray(subtask.description)}`);
-					}
-				});
 			}
 		}
 
-		if (task.testStrategy) {
+		// Display suggested actions
-			console.log(`\n${chalk.blue.bold('Test Strategy:')}`);
+		displaySuggestedActions(task.id);
-			console.log(task.testStrategy);
-		}
-
-		console.log(`\n${chalk.gray('Storage: ' + result.storageType)}`);
 	}
 
 	/**

apps/cli/src/ui/components/dashboard.component.ts

@@ -0,0 +1,567 @@
+/**
+ * @fileoverview Dashboard components for Task Master CLI
+ * Displays project statistics and dependency information
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import type { Task, TaskPriority } from '@tm/core/types';
+
+/**
+ * Statistics for task collection
+ */
+export interface TaskStatistics {
+	total: number;
+	done: number;
+	inProgress: number;
+	pending: number;
+	blocked: number;
+	deferred: number;
+	cancelled: number;
+	review?: number;
+	completionPercentage: number;
+}
+
+/**
+ * Statistics for dependencies
+ */
+export interface DependencyStatistics {
+	tasksWithNoDeps: number;
+	tasksReadyToWork: number;
+	tasksBlockedByDeps: number;
+	mostDependedOnTaskId?: number;
+	mostDependedOnCount?: number;
+	avgDependenciesPerTask: number;
+}
+
+/**
+ * Next task information
+ */
+export interface NextTaskInfo {
+	id: string | number;
+	title: string;
+	priority?: TaskPriority;
+	dependencies?: (string | number)[];
+	complexity?: number | string;
+}
+
+/**
+ * Status breakdown for progress bars
+ */
+export interface StatusBreakdown {
+	'in-progress'?: number;
+	pending?: number;
+	blocked?: number;
+	deferred?: number;
+	cancelled?: number;
+	review?: number;
+}
+
+/**
+ * Create a progress bar with color-coded status segments
+ */
+function createProgressBar(
+	completionPercentage: number,
+	width: number = 30,
+	statusBreakdown?: StatusBreakdown
+): string {
+	// If no breakdown provided, use simple green bar
+	if (!statusBreakdown) {
+		const filled = Math.round((completionPercentage / 100) * width);
+		const empty = width - filled;
+		return chalk.green('█').repeat(filled) + chalk.gray('░').repeat(empty);
+	}
+
+	// Build the bar with different colored sections
+	// Order matches the status display: Done, Cancelled, Deferred, In Progress, Review, Pending, Blocked
+	let bar = '';
+	let charsUsed = 0;
+
+	// 1. Green filled blocks for completed tasks (done)
+	const completedChars = Math.round((completionPercentage / 100) * width);
+	if (completedChars > 0) {
+		bar += chalk.green('█').repeat(completedChars);
+		charsUsed += completedChars;
+	}
+
+	// 2. Gray filled blocks for cancelled (won't be done)
+	if (statusBreakdown.cancelled && charsUsed < width) {
+		const cancelledChars = Math.round(
+			(statusBreakdown.cancelled / 100) * width
+		);
+		const actualChars = Math.min(cancelledChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.gray('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 3. Gray filled blocks for deferred (won't be done now)
+	if (statusBreakdown.deferred && charsUsed < width) {
+		const deferredChars = Math.round((statusBreakdown.deferred / 100) * width);
+		const actualChars = Math.min(deferredChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.gray('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 4. Blue filled blocks for in-progress (actively working)
+	if (statusBreakdown['in-progress'] && charsUsed < width) {
+		const inProgressChars = Math.round(
+			(statusBreakdown['in-progress'] / 100) * width
+		);
+		const actualChars = Math.min(inProgressChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.blue('█').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 5. Magenta empty blocks for review (almost done)
+	if (statusBreakdown.review && charsUsed < width) {
+		const reviewChars = Math.round((statusBreakdown.review / 100) * width);
+		const actualChars = Math.min(reviewChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.magenta('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 6. Yellow empty blocks for pending (ready to start)
+	if (statusBreakdown.pending && charsUsed < width) {
+		const pendingChars = Math.round((statusBreakdown.pending / 100) * width);
+		const actualChars = Math.min(pendingChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.yellow('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// 7. Red empty blocks for blocked (can't start yet)
+	if (statusBreakdown.blocked && charsUsed < width) {
+		const blockedChars = Math.round((statusBreakdown.blocked / 100) * width);
+		const actualChars = Math.min(blockedChars, width - charsUsed);
+		if (actualChars > 0) {
+			bar += chalk.red('░').repeat(actualChars);
+			charsUsed += actualChars;
+		}
+	}
+
+	// Fill any remaining space with gray empty yellow blocks
+	if (charsUsed < width) {
+		bar += chalk.yellow('░').repeat(width - charsUsed);
+	}
+
+	return bar;
+}
+
+/**
+ * Calculate task statistics from a list of tasks
+ */
+export function calculateTaskStatistics(tasks: Task[]): TaskStatistics {
+	const stats: TaskStatistics = {
+		total: tasks.length,
+		done: 0,
+		inProgress: 0,
+		pending: 0,
+		blocked: 0,
+		deferred: 0,
+		cancelled: 0,
+		review: 0,
+		completionPercentage: 0
+	};
+
+	tasks.forEach((task) => {
+		switch (task.status) {
+			case 'done':
+				stats.done++;
+				break;
+			case 'in-progress':
+				stats.inProgress++;
+				break;
+			case 'pending':
+				stats.pending++;
+				break;
+			case 'blocked':
+				stats.blocked++;
+				break;
+			case 'deferred':
+				stats.deferred++;
+				break;
+			case 'cancelled':
+				stats.cancelled++;
+				break;
+			case 'review':
+				stats.review = (stats.review || 0) + 1;
+				break;
+		}
+	});
+
+	stats.completionPercentage =
+		stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0;
+
+	return stats;
+}
+
+/**
+ * Calculate subtask statistics from tasks
+ */
+export function calculateSubtaskStatistics(tasks: Task[]): TaskStatistics {
+	const stats: TaskStatistics = {
+		total: 0,
+		done: 0,
+		inProgress: 0,
+		pending: 0,
+		blocked: 0,
+		deferred: 0,
+		cancelled: 0,
+		review: 0,
+		completionPercentage: 0
+	};
+
+	tasks.forEach((task) => {
+		if (task.subtasks && task.subtasks.length > 0) {
+			task.subtasks.forEach((subtask) => {
+				stats.total++;
+				switch (subtask.status) {
+					case 'done':
+						stats.done++;
+						break;
+					case 'in-progress':
+						stats.inProgress++;
+						break;
+					case 'pending':
+						stats.pending++;
+						break;
+					case 'blocked':
+						stats.blocked++;
+						break;
+					case 'deferred':
+						stats.deferred++;
+						break;
+					case 'cancelled':
+						stats.cancelled++;
+						break;
+					case 'review':
+						stats.review = (stats.review || 0) + 1;
+						break;
+				}
+			});
+		}
+	});
+
+	stats.completionPercentage =
+		stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0;
+
+	return stats;
+}
+
+/**
+ * Calculate dependency statistics
+ */
+export function calculateDependencyStatistics(
+	tasks: Task[]
+): DependencyStatistics {
+	const completedTaskIds = new Set(
+		tasks.filter((t) => t.status === 'done').map((t) => t.id)
+	);
+
+	const tasksWithNoDeps = tasks.filter(
+		(t) =>
+			t.status !== 'done' && (!t.dependencies || t.dependencies.length === 0)
+	).length;
+
+	const tasksWithAllDepsSatisfied = tasks.filter(
+		(t) =>
+			t.status !== 'done' &&
+			t.dependencies &&
+			t.dependencies.length > 0 &&
+			t.dependencies.every((depId) => completedTaskIds.has(depId))
+	).length;
+
+	const tasksBlockedByDeps = tasks.filter(
+		(t) =>
+			t.status !== 'done' &&
+			t.dependencies &&
+			t.dependencies.length > 0 &&
+			!t.dependencies.every((depId) => completedTaskIds.has(depId))
+	).length;
+
+	// Calculate most depended-on task
+	const dependencyCount: Record<string, number> = {};
+	tasks.forEach((task) => {
+		if (task.dependencies && task.dependencies.length > 0) {
+			task.dependencies.forEach((depId) => {
+				const key = String(depId);
+				dependencyCount[key] = (dependencyCount[key] || 0) + 1;
+			});
+		}
+	});
+
+	let mostDependedOnTaskId: number | undefined;
+	let mostDependedOnCount = 0;
+
+	for (const [taskId, count] of Object.entries(dependencyCount)) {
+		if (count > mostDependedOnCount) {
+			mostDependedOnCount = count;
+			mostDependedOnTaskId = parseInt(taskId);
+		}
+	}
+
+	// Calculate average dependencies
+	const totalDependencies = tasks.reduce(
+		(sum, task) => sum + (task.dependencies ? task.dependencies.length : 0),
+		0
+	);
+	const avgDependenciesPerTask =
+		tasks.length > 0 ? totalDependencies / tasks.length : 0;
+
+	return {
+		tasksWithNoDeps,
+		tasksReadyToWork: tasksWithNoDeps + tasksWithAllDepsSatisfied,
+		tasksBlockedByDeps,
+		mostDependedOnTaskId,
+		mostDependedOnCount,
+		avgDependenciesPerTask
+	};
+}
+
+/**
+ * Get priority counts
+ */
+export function getPriorityBreakdown(
+	tasks: Task[]
+): Record<TaskPriority, number> {
+	const breakdown: Record<TaskPriority, number> = {
+		critical: 0,
+		high: 0,
+		medium: 0,
+		low: 0
+	};
+
+	tasks.forEach((task) => {
+		const priority = task.priority || 'medium';
+		breakdown[priority]++;
+	});
+
+	return breakdown;
+}
+
+/**
+ * Calculate status breakdown as percentages
+ */
+function calculateStatusBreakdown(stats: TaskStatistics): StatusBreakdown {
+	if (stats.total === 0) return {};
+
+	return {
+		'in-progress': (stats.inProgress / stats.total) * 100,
+		pending: (stats.pending / stats.total) * 100,
+		blocked: (stats.blocked / stats.total) * 100,
+		deferred: (stats.deferred / stats.total) * 100,
+		cancelled: (stats.cancelled / stats.total) * 100,
+		review: ((stats.review || 0) / stats.total) * 100
+	};
+}
+
+/**
+ * Format status counts in the correct order with colors
+ * @param stats - The statistics object containing counts
+ * @param isSubtask - Whether this is for subtasks (affects "Done" vs "Completed" label)
+ */
+function formatStatusLine(
+	stats: TaskStatistics,
+	isSubtask: boolean = false
+): string {
+	const parts: string[] = [];
+
+	// Order: Done, Cancelled, Deferred, In Progress, Review, Pending, Blocked
+	if (isSubtask) {
+		parts.push(`Completed: ${chalk.green(`${stats.done}/${stats.total}`)}`);
+	} else {
+		parts.push(`Done: ${chalk.green(stats.done)}`);
+	}
+
+	parts.push(`Cancelled: ${chalk.gray(stats.cancelled)}`);
+	parts.push(`Deferred: ${chalk.gray(stats.deferred)}`);
+
+	// Add line break for second row
+	const firstLine = parts.join('  ');
+	parts.length = 0;
+
+	parts.push(`In Progress: ${chalk.blue(stats.inProgress)}`);
+	parts.push(`Review: ${chalk.magenta(stats.review || 0)}`);
+	parts.push(`Pending: ${chalk.yellow(stats.pending)}`);
+	parts.push(`Blocked: ${chalk.red(stats.blocked)}`);
+
+	const secondLine = parts.join('  ');
+
+	return firstLine + '\n' + secondLine;
+}
+
+/**
+ * Display the project dashboard box
+ */
+export function displayProjectDashboard(
+	taskStats: TaskStatistics,
+	subtaskStats: TaskStatistics,
+	priorityBreakdown: Record<TaskPriority, number>
+): string {
+	// Calculate status breakdowns using the helper function
+	const taskStatusBreakdown = calculateStatusBreakdown(taskStats);
+	const subtaskStatusBreakdown = calculateStatusBreakdown(subtaskStats);
+
+	// Create progress bars with the breakdowns
+	const taskProgressBar = createProgressBar(
+		taskStats.completionPercentage,
+		30,
+		taskStatusBreakdown
+	);
+	const subtaskProgressBar = createProgressBar(
+		subtaskStats.completionPercentage,
+		30,
+		subtaskStatusBreakdown
+	);
+
+	const taskPercentage = `${taskStats.completionPercentage}% ${taskStats.done}/${taskStats.total}`;
+	const subtaskPercentage = `${subtaskStats.completionPercentage}% ${subtaskStats.done}/${subtaskStats.total}`;
+
+	const content =
+		chalk.white.bold('Project Dashboard') +
+		'\n' +
+		`Tasks Progress: ${taskProgressBar} ${chalk.yellow(taskPercentage)}\n` +
+		formatStatusLine(taskStats, false) +
+		'\n\n' +
+		`Subtasks Progress: ${subtaskProgressBar} ${chalk.cyan(subtaskPercentage)}\n` +
+		formatStatusLine(subtaskStats, true) +
+		'\n\n' +
+		chalk.cyan.bold('Priority Breakdown:') +
+		'\n' +
+		`${chalk.red('•')} ${chalk.white('High priority:')} ${priorityBreakdown.high}\n` +
+		`${chalk.yellow('•')} ${chalk.white('Medium priority:')} ${priorityBreakdown.medium}\n` +
+		`${chalk.green('•')} ${chalk.white('Low priority:')} ${priorityBreakdown.low}`;
+
+	return content;
+}
+
+/**
+ * Display the dependency dashboard box
+ */
+export function displayDependencyDashboard(
+	depStats: DependencyStatistics,
+	nextTask?: NextTaskInfo
+): string {
+	const content =
+		chalk.white.bold('Dependency Status & Next Task') +
+		'\n' +
+		chalk.cyan.bold('Dependency Metrics:') +
+		'\n' +
+		`${chalk.green('•')} ${chalk.white('Tasks with no dependencies:')} ${depStats.tasksWithNoDeps}\n` +
+		`${chalk.green('•')} ${chalk.white('Tasks ready to work on:')} ${depStats.tasksReadyToWork}\n` +
+		`${chalk.yellow('•')} ${chalk.white('Tasks blocked by dependencies:')} ${depStats.tasksBlockedByDeps}\n` +
+		`${chalk.magenta('•')} ${chalk.white('Most depended-on task:')} ${
+			depStats.mostDependedOnTaskId
+				? chalk.cyan(
+						`#${depStats.mostDependedOnTaskId} (${depStats.mostDependedOnCount} dependents)`
+					)
+				: chalk.gray('None')
+		}\n` +
+		`${chalk.blue('•')} ${chalk.white('Avg dependencies per task:')} ${depStats.avgDependenciesPerTask.toFixed(1)}\n\n` +
+		chalk.cyan.bold('Next Task to Work On:') +
+		'\n' +
+		`ID: ${nextTask ? chalk.cyan(String(nextTask.id)) : chalk.gray('N/A')} - ${
+			nextTask
+				? chalk.white.bold(nextTask.title)
+				: chalk.yellow('No task available')
+		}\n` +
+		`Priority: ${nextTask?.priority || chalk.gray('N/A')}  Dependencies: ${
+			nextTask?.dependencies?.length
+				? chalk.cyan(nextTask.dependencies.join(', '))
+				: chalk.gray('None')
+		}\n` +
+		`Complexity: ${nextTask?.complexity || chalk.gray('N/A')}`;
+
+	return content;
+}
+
+/**
+ * Display dashboard boxes side by side or stacked
+ */
+export function displayDashboards(
+	taskStats: TaskStatistics,
+	subtaskStats: TaskStatistics,
+	priorityBreakdown: Record<TaskPriority, number>,
+	depStats: DependencyStatistics,
+	nextTask?: NextTaskInfo
+): void {
+	const projectDashboardContent = displayProjectDashboard(
+		taskStats,
+		subtaskStats,
+		priorityBreakdown
+	);
+	const dependencyDashboardContent = displayDependencyDashboard(
+		depStats,
+		nextTask
+	);
+
+	// Get terminal width
+	const terminalWidth = process.stdout.columns || 80;
+	const minDashboardWidth = 50;
+	const minDependencyWidth = 50;
+	const totalMinWidth = minDashboardWidth + minDependencyWidth + 4;
+
+	// If terminal is wide enough, show side by side
+	if (terminalWidth >= totalMinWidth) {
+		const halfWidth = Math.floor(terminalWidth / 2);
+		const boxContentWidth = halfWidth - 4;
+
+		const dashboardBox = boxen(projectDashboardContent, {
+			padding: 1,
+			borderColor: 'blue',
+			borderStyle: 'round',
+			width: boxContentWidth,
+			dimBorder: false
+		});
+
+		const dependencyBox = boxen(dependencyDashboardContent, {
+			padding: 1,
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			width: boxContentWidth,
+			dimBorder: false
+		});
+
+		// Create side-by-side layout
+		const dashboardLines = dashboardBox.split('\n');
+		const dependencyLines = dependencyBox.split('\n');
+		const maxHeight = Math.max(dashboardLines.length, dependencyLines.length);
+
+		const combinedLines = [];
+		for (let i = 0; i < maxHeight; i++) {
+			const dashLine = i < dashboardLines.length ? dashboardLines[i] : '';
+			const depLine = i < dependencyLines.length ? dependencyLines[i] : '';
+			const paddedDashLine = dashLine.padEnd(halfWidth, ' ');
+			combinedLines.push(paddedDashLine + depLine);
+		}
+
+		console.log(combinedLines.join('\n'));
+	} else {
+		// Show stacked vertically
+		const dashboardBox = boxen(projectDashboardContent, {
+			padding: 1,
+			borderColor: 'blue',
+			borderStyle: 'round',
+			margin: { top: 0, bottom: 1 }
+		});
+
+		const dependencyBox = boxen(dependencyDashboardContent, {
+			padding: 1,
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			margin: { top: 0, bottom: 1 }
+		});
+
+		console.log(dashboardBox);
+		console.log(dependencyBox);
+	}
+}

apps/cli/src/ui/components/header.component.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Task Master header component
+ * Displays the banner, version, project info, and file path
+ */
+
+import chalk from 'chalk';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+
+/**
+ * Header configuration options
+ */
+export interface HeaderOptions {
+	title?: string;
+	tag?: string;
+	filePath?: string;
+}
+
+/**
+ * Display the Task Master header with project info
+ */
+export function displayHeader(options: HeaderOptions = {}): void {
+	const { filePath, tag } = options;
+
+	// Display tag and file path info
+	if (tag) {
+		let tagInfo = '';
+
+		if (tag && tag !== 'master') {
+			tagInfo = `🏷 tag: ${chalk.cyan(tag)}`;
+		} else {
+			tagInfo = `🏷 tag: ${chalk.cyan('master')}`;
+		}
+
+		console.log(tagInfo);
+
+		if (filePath) {
+			// Convert to absolute path if it's relative
+			const absolutePath = filePath.startsWith('/')
+				? filePath
+				: `${process.cwd()}/${filePath}`;
+			console.log(`Listing tasks from: ${chalk.dim(absolutePath)}`);
+		}
+
+		console.log(); // Empty line for spacing
+	}
+}

apps/cli/src/ui/components/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview UI components exports
+ */
+
+export * from './header.component.js';
+export * from './dashboard.component.js';
+export * from './next-task.component.js';
+export * from './suggested-steps.component.js';
+export * from './task-detail.component.js';

apps/cli/src/ui/components/next-task.component.ts

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Next task recommendation component
+ * Displays detailed information about the recommended next task
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import type { Task } from '@tm/core/types';
+
+/**
+ * Next task display options
+ */
+export interface NextTaskDisplayOptions {
+	id: string | number;
+	title: string;
+	priority?: string;
+	status?: string;
+	dependencies?: (string | number)[];
+	description?: string;
+}
+
+/**
+ * Display the recommended next task section
+ */
+export function displayRecommendedNextTask(
+	task: NextTaskDisplayOptions | undefined
+): void {
+	if (!task) {
+		// If no task available, show a message
+		console.log(
+			boxen(
+				chalk.yellow(
+					'No tasks available to work on. All tasks are either completed, blocked by dependencies, or in progress.'
+				),
+				{
+					padding: 1,
+					borderStyle: 'round',
+					borderColor: 'yellow',
+					title: '⚠ NO TASKS AVAILABLE ⚠',
+					titleAlignment: 'center'
+				}
+			)
+		);
+		return;
+	}
+
+	// Build the content for the next task box
+	const content = [];
+
+	// Task header with ID and title
+	content.push(
+		`🔥 ${chalk.hex('#FF8800').bold('Next Task to Work On:')} ${chalk.yellow(`#${task.id}`)}${chalk.hex('#FF8800').bold(` - ${task.title}`)}`
+	);
+	content.push('');
+
+	// Priority and Status line
+	const statusLine = [];
+	if (task.priority) {
+		const priorityColor =
+			task.priority === 'high'
+				? chalk.red
+				: task.priority === 'medium'
+					? chalk.yellow
+					: chalk.gray;
+		statusLine.push(`Priority: ${priorityColor.bold(task.priority)}`);
+	}
+	if (task.status) {
+		const statusDisplay =
+			task.status === 'pending'
+				? chalk.yellow('○ pending')
+				: task.status === 'in-progress'
+					? chalk.blue('▶ in-progress')
+					: chalk.gray(task.status);
+		statusLine.push(`Status: ${statusDisplay}`);
+	}
+	content.push(statusLine.join('  '));
+
+	// Dependencies
+	const depsDisplay =
+		!task.dependencies || task.dependencies.length === 0
+			? chalk.gray('None')
+			: chalk.cyan(task.dependencies.join(', '));
+	content.push(`Dependencies: ${depsDisplay}`);
+
+	// Description if available
+	if (task.description) {
+		content.push('');
+		content.push(`Description: ${chalk.white(task.description)}`);
+	}
+
+	// Action commands
+	content.push('');
+	content.push(
+		`${chalk.cyan('Start working:')} ${chalk.yellow(`task-master set-status --id=${task.id} --status=in-progress`)}`
+	);
+	content.push(
+		`${chalk.cyan('View details:')} ${chalk.yellow(`task-master show ${task.id}`)}`
+	);
+
+	// Display in a styled box with orange border
+	console.log(
+		boxen(content.join('\n'), {
+			padding: 1,
+			margin: { top: 1, bottom: 1 },
+			borderStyle: 'round',
+			borderColor: '#FFA500', // Orange color
+			title: chalk.hex('#FFA500')('⚡ RECOMMENDED NEXT TASK ⚡'),
+			titleAlignment: 'center',
+			width: process.stdout.columns * 0.97,
+			fullscreen: false
+		})
+	);
+}
+
+/**
+ * Get task description from the full task object
+ */
+export function getTaskDescription(task: Task): string | undefined {
+	// Try to get description from the task
+	// This could be from task.description or the first line of task.details
+	if ('description' in task && task.description) {
+		return task.description as string;
+	}
+
+	if ('details' in task && task.details) {
+		// Take first sentence or line from details
+		const details = task.details as string;
+		const firstLine = details.split('\n')[0];
+		const firstSentence = firstLine.split('.')[0];
+		return firstSentence;
+	}
+
+	return undefined;
+}

apps/cli/src/ui/components/suggested-steps.component.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Suggested next steps component
+ * Displays helpful command suggestions at the end of the list
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+
+/**
+ * Display suggested next steps section
+ */
+export function displaySuggestedNextSteps(): void {
+	const steps = [
+		`${chalk.cyan('1.')} Run ${chalk.yellow('task-master next')} to see what to work on next`,
+		`${chalk.cyan('2.')} Run ${chalk.yellow('task-master expand --id=<id>')} to break down a task into subtasks`,
+		`${chalk.cyan('3.')} Run ${chalk.yellow('task-master set-status --id=<id> --status=done')} to mark a task as complete`
+	];
+
+	console.log(
+		boxen(
+			chalk.white.bold('Suggested Next Steps:') + '\n\n' + steps.join('\n'),
+			{
+				padding: 1,
+				margin: { top: 0, bottom: 1 },
+				borderStyle: 'round',
+				borderColor: 'gray',
+				width: process.stdout.columns * 0.97
+			}
+		)
+	);
+}

apps/cli/src/ui/components/task-detail.component.ts

@@ -0,0 +1,264 @@
+/**
+ * @fileoverview Task detail component for show command
+ * Displays detailed task information in a structured format
+ */
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import { marked, MarkedExtension } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import type { Task } from '@tm/core/types';
+import { getStatusWithColor, getPriorityWithColor } from '../../utils/ui.js';
+
+// Configure marked to use terminal renderer with subtle colors
+marked.use(
+	markedTerminal({
+		// More subtle colors that match the overall design
+		code: (code: string) => {
+			// Custom code block handler to preserve formatting
+			return code
+				.split('\n')
+				.map((line) => '    ' + chalk.cyan(line))
+				.join('\n');
+		},
+		blockquote: chalk.gray.italic,
+		html: chalk.gray,
+		heading: chalk.white.bold, // White bold for headings
+		hr: chalk.gray,
+		listitem: chalk.white, // White for list items
+		paragraph: chalk.white, // White for paragraphs (default text color)
+		strong: chalk.white.bold, // White bold for strong text
+		em: chalk.white.italic, // White italic for emphasis
+		codespan: chalk.cyan, // Cyan for inline code (no background)
+		del: chalk.dim.strikethrough,
+		link: chalk.blue,
+		href: chalk.blue.underline,
+		// Add more explicit code block handling
+		showSectionPrefix: false,
+		unescape: true,
+		emoji: false,
+		// Try to preserve whitespace in code blocks
+		tab: 4,
+		width: 120
+	}) as MarkedExtension
+);
+
+// Also set marked options to preserve whitespace
+marked.setOptions({
+	breaks: true,
+	gfm: true
+});
+
+/**
+ * Display the task header with tag
+ */
+export function displayTaskHeader(
+	taskId: string | number,
+	title: string
+): void {
+	// Display task header box
+	console.log(
+		boxen(chalk.white.bold(`Task: #${taskId} - ${title}`), {
+			padding: { top: 0, bottom: 0, left: 1, right: 1 },
+			borderColor: 'blue',
+			borderStyle: 'round'
+		})
+	);
+}
+
+/**
+ * Display task properties in a table format
+ */
+export function displayTaskProperties(task: Task): void {
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+	// Create table for task properties - simple 2-column layout
+	const table = new Table({
+		head: [],
+		style: {
+			head: [],
+			border: ['grey']
+		},
+		colWidths: [
+			Math.floor(terminalWidth * 0.2),
+			Math.floor(terminalWidth * 0.8)
+		],
+		wordWrap: true
+	});
+
+	const deps =
+		task.dependencies && task.dependencies.length > 0
+			? task.dependencies.map((d) => String(d)).join(', ')
+			: 'None';
+
+	// Build the left column (labels) and right column (values)
+	const labels = [
+		chalk.cyan('ID:'),
+		chalk.cyan('Title:'),
+		chalk.cyan('Status:'),
+		chalk.cyan('Priority:'),
+		chalk.cyan('Dependencies:'),
+		chalk.cyan('Complexity:'),
+		chalk.cyan('Description:')
+	].join('\n');
+
+	const values = [
+		String(task.id),
+		task.title,
+		getStatusWithColor(task.status),
+		getPriorityWithColor(task.priority),
+		deps,
+		'N/A',
+		task.description || ''
+	].join('\n');
+
+	table.push([labels, values]);
+
+	console.log(table.toString());
+}
+
+/**
+ * Display implementation details in a box
+ */
+export function displayImplementationDetails(details: string): void {
+	// Handle all escaped characters properly
+	const cleanDetails = details
+		.replace(/\\n/g, '\n') // Convert \n to actual newlines
+		.replace(/\\t/g, '\t') // Convert \t to actual tabs
+		.replace(/\\"/g, '"') // Convert \" to actual quotes
+		.replace(/\\\\/g, '\\'); // Convert \\ to single backslash
+
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+
+	// Parse markdown to terminal-friendly format
+	const markdownResult = marked(cleanDetails);
+	const formattedDetails =
+		typeof markdownResult === 'string' ? markdownResult.trim() : cleanDetails; // Fallback to original if Promise
+
+	console.log(
+		boxen(
+			chalk.white.bold('Implementation Details:') + '\n\n' + formattedDetails,
+			{
+				padding: 1,
+				borderStyle: 'round',
+				borderColor: 'cyan', // Changed to cyan to match the original
+				width: terminalWidth // Fixed width to match the original
+			}
+		)
+	);
+}
+
+/**
+ * Display test strategy in a box
+ */
+export function displayTestStrategy(testStrategy: string): void {
+	// Handle all escaped characters properly (same as implementation details)
+	const cleanStrategy = testStrategy
+		.replace(/\\n/g, '\n') // Convert \n to actual newlines
+		.replace(/\\t/g, '\t') // Convert \t to actual tabs
+		.replace(/\\"/g, '"') // Convert \" to actual quotes
+		.replace(/\\\\/g, '\\'); // Convert \\ to single backslash
+
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+
+	// Parse markdown to terminal-friendly format (same as implementation details)
+	const markdownResult = marked(cleanStrategy);
+	const formattedStrategy =
+		typeof markdownResult === 'string' ? markdownResult.trim() : cleanStrategy; // Fallback to original if Promise
+
+	console.log(
+		boxen(chalk.white.bold('Test Strategy:') + '\n\n' + formattedStrategy, {
+			padding: 1,
+			borderStyle: 'round',
+			borderColor: 'cyan', // Changed to cyan to match implementation details
+			width: terminalWidth
+		})
+	);
+}
+
+/**
+ * Display subtasks in a table format
+ */
+export function displaySubtasks(
+	subtasks: Array<{
+		id: string | number;
+		title: string;
+		status: any;
+		description?: string;
+		dependencies?: string[];
+	}>,
+	parentId: string | number
+): void {
+	const terminalWidth = process.stdout.columns * 0.95 || 100;
+	// Display subtasks header
+	console.log(
+		boxen(chalk.magenta.bold('Subtasks'), {
+			padding: { top: 0, bottom: 0, left: 1, right: 1 },
+			borderColor: 'magenta',
+			borderStyle: 'round',
+			margin: { top: 1, bottom: 0 }
+		})
+	);
+
+	// Create subtasks table
+	const table = new Table({
+		head: [
+			chalk.magenta.bold('ID'),
+			chalk.magenta.bold('Status'),
+			chalk.magenta.bold('Title'),
+			chalk.magenta.bold('Deps')
+		],
+		style: {
+			head: [],
+			border: ['grey']
+		},
+		colWidths: [
+			Math.floor(terminalWidth * 0.1),
+			Math.floor(terminalWidth * 0.15),
+			Math.floor(terminalWidth * 0.6),
+			Math.floor(terminalWidth * 0.15)
+		],
+		wordWrap: true
+	});
+
+	subtasks.forEach((subtask) => {
+		const subtaskId = `${parentId}.${subtask.id}`;
+
+		// Format dependencies
+		const deps =
+			subtask.dependencies && subtask.dependencies.length > 0
+				? subtask.dependencies.join(', ')
+				: 'None';
+
+		table.push([
+			subtaskId,
+			getStatusWithColor(subtask.status),
+			subtask.title,
+			deps
+		]);
+	});
+
+	console.log(table.toString());
+}
+
+/**
+ * Display suggested actions
+ */
+export function displaySuggestedActions(taskId: string | number): void {
+	console.log(
+		boxen(
+			chalk.white.bold('Suggested Actions:') +
+				'\n\n' +
+				`${chalk.cyan('1.')} Run ${chalk.yellow(`task-master set-status --id=${taskId} --status=in-progress`)} to start working\n` +
+				`${chalk.cyan('2.')} Run ${chalk.yellow(`task-master expand --id=${taskId}`)} to break down into subtasks\n` +
+				`${chalk.cyan('3.')} Run ${chalk.yellow(`task-master update-task --id=${taskId} --prompt="..."`)} to update details`,
+			{
+				padding: 1,
+				margin: { top: 1 },
+				borderStyle: 'round',
+				borderColor: 'green',
+				width: process.stdout.columns * 0.95 || 100
+			}
+		)
+	);
+}

apps/cli/src/ui/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Main UI exports
+ */
+
+// Export all components
+export * from './components/index.js';
+
+// Re-export existing UI utilities
+export * from '../utils/ui.js';

apps/cli/src/utils/ui.ts

@@ -18,19 +18,39 @@ export function getStatusWithColor(
 	const statusConfig = {
 		done: {
 			color: chalk.green,
-			icon: String.fromCharCode(8730),
+			icon: '✓',
-			tableIcon: String.fromCharCode(8730)
+			tableIcon: '✓'
-		}, // √
+		},
-		pending: { color: chalk.yellow, icon: 'o', tableIcon: 'o' },
+		pending: {
+			color: chalk.yellow,
+			icon: '○',
+			tableIcon: '○'
+		},
 		'in-progress': {
 			color: chalk.hex('#FFA500'),
-			icon: String.fromCharCode(9654),
+			icon: '▶',
-			tableIcon: '>'
+			tableIcon: '▶'
-		}, // ▶
+		},
-		deferred: { color: chalk.gray, icon: 'x', tableIcon: 'x' },
+		deferred: {
-		blocked: { color: chalk.red, icon: '!', tableIcon: '!' },
+			color: chalk.gray,
-		review: { color: chalk.magenta, icon: '?', tableIcon: '?' },
+			icon: 'x',
-		cancelled: { color: chalk.gray, icon: 'X', tableIcon: 'X' }
+			tableIcon: 'x'
+		},
+		review: {
+			color: chalk.magenta,
+			icon: '?',
+			tableIcon: '?'
+		},
+		cancelled: {
+			color: chalk.gray,
+			icon: 'x',
+			tableIcon: 'x'
+		},
+		blocked: {
+			color: chalk.red,
+			icon: '!',
+			tableIcon: '!'
+		}
 	};
 
 	const config = statusConfig[status] || {
@@ -39,18 +59,7 @@ export function getStatusWithColor(
 		tableIcon: 'X'
 	};
 
-	// Use simple ASCII characters for stable display
+	const icon = forTable ? config.tableIcon : config.icon;
-	const simpleIcons = {
-		done: String.fromCharCode(8730), // √
-		pending: 'o',
-		'in-progress': '>',
-		deferred: 'x',
-		blocked: '!',
-		review: '?',
-		cancelled: 'X'
-	};
-
-	const icon = forTable ? simpleIcons[status] || 'X' : config.icon;
 	return config.color(`${icon} ${status}`);
 }
 
@@ -245,10 +254,24 @@ export function createTaskTable(
 	} = options || {};
 
 	// Calculate dynamic column widths based on terminal width
-	const terminalWidth = process.stdout.columns || 100;
+	const terminalWidth = process.stdout.columns * 0.9 || 100;
+	// Adjust column widths to better match the original layout
 	const baseColWidths = showComplexity
-		? [8, Math.floor(terminalWidth * 0.35), 18, 12, 15, 12] // ID, Title, Status, Priority, Dependencies, Complexity
+		? [
-		: [8, Math.floor(terminalWidth * 0.4), 18, 12, 20]; // ID, Title, Status, Priority, Dependencies
+				Math.floor(terminalWidth * 0.06),
+				Math.floor(terminalWidth * 0.4),
+				Math.floor(terminalWidth * 0.15),
+				Math.floor(terminalWidth * 0.12),
+				Math.floor(terminalWidth * 0.2),
+				Math.floor(terminalWidth * 0.12)
+			] // ID, Title, Status, Priority, Dependencies, Complexity
+		: [
+				Math.floor(terminalWidth * 0.08),
+				Math.floor(terminalWidth * 0.4),
+				Math.floor(terminalWidth * 0.18),
+				Math.floor(terminalWidth * 0.12),
+				Math.floor(terminalWidth * 0.2)
+			]; // ID, Title, Status, Priority, Dependencies
 
 	const headers = [
 		chalk.blue.bold('ID'),
@@ -284,11 +307,19 @@ export function createTaskTable(
 		];
 
 		if (showDependencies) {
-			row.push(formatDependenciesWithStatus(task.dependencies, tasks));
+			// For table display, show simple format without status icons
+			if (!task.dependencies || task.dependencies.length === 0) {
+				row.push(chalk.gray('None'));
+			} else {
+				row.push(
+					chalk.cyan(task.dependencies.map((d) => String(d)).join(', '))
+				);
+			}
 		}
 
-		if (showComplexity && 'complexity' in task) {
+		if (showComplexity) {
-			row.push(getComplexityWithColor(task.complexity as number | string));
+			// Show N/A if no complexity score
+			row.push(chalk.gray('N/A'));
 		}
 
 		table.push(row);

bin/task-master.js

@@ -20,357 +20,8 @@
  * Main entry point for globally installed package
  */
 
-import { fileURLToPath } from 'url';
+// Direct imports instead of spawning child processes
-import { dirname, resolve } from 'path';
+import { runCLI } from '../scripts/modules/commands.js';
-import { createRequire } from 'module';
-import { spawn } from 'child_process';
-import { Command } from 'commander';
-import { displayHelp, displayBanner } from '../scripts/modules/ui.js';
-import { registerCommands } from '../scripts/modules/commands.js';
-import { detectCamelCaseFlags } from '../scripts/modules/utils.js';
-import chalk from 'chalk';
 
-const __filename = fileURLToPath(import.meta.url);
+// Simply run the CLI directly
-const __dirname = dirname(__filename);
+runCLI();
-const require = createRequire(import.meta.url);
-
-// Get package information
-const packageJson = require('../package.json');
-const version = packageJson.version;
-
-// Get paths to script files
-const devScriptPath = resolve(__dirname, '../scripts/dev.js');
-const initScriptPath = resolve(__dirname, '../scripts/init.js');
-
-// Helper function to run dev.js with arguments
-function runDevScript(args) {
-	// Debug: Show the transformed arguments when DEBUG=1 is set
-	if (process.env.DEBUG === '1') {
-		console.error('\nDEBUG - CLI Wrapper Analysis:');
-		console.error('- Original command: ' + process.argv.join(' '));
-		console.error('- Transformed args: ' + args.join(' '));
-		console.error(
-			'- dev.js will receive: node ' +
-				devScriptPath +
-				' ' +
-				args.join(' ') +
-				'\n'
-		);
-	}
-
-	// For testing: If TEST_MODE is set, just print args and exit
-	if (process.env.TEST_MODE === '1') {
-		console.log('Would execute:');
-		console.log(`node ${devScriptPath} ${args.join(' ')}`);
-		process.exit(0);
-		return;
-	}
-
-	const child = spawn('node', [devScriptPath, ...args], {
-		stdio: 'inherit',
-		cwd: process.cwd()
-	});
-
-	child.on('close', (code) => {
-		process.exit(code);
-	});
-}
-
-// Helper function to detect camelCase and convert to kebab-case
-const toKebabCase = (str) => str.replace(/([A-Z])/g, '-$1').toLowerCase();
-
-/**
- * Create a wrapper action that passes the command to dev.js
- * @param {string} commandName - The name of the command
- * @returns {Function} Wrapper action function
- */
-function createDevScriptAction(commandName) {
-	return (options, cmd) => {
-		// Check for camelCase flags and error out with helpful message
-		const camelCaseFlags = detectCamelCaseFlags(process.argv);
-
-		// If camelCase flags were found, show error and exit
-		if (camelCaseFlags.length > 0) {
-			console.error('\nError: Please use kebab-case for CLI flags:');
-			camelCaseFlags.forEach((flag) => {
-				console.error(`  Instead of: --${flag.original}`);
-				console.error(`  Use:        --${flag.kebabCase}`);
-			});
-			console.error(
-				'\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n'
-			);
-			process.exit(1);
-		}
-
-		// Since we've ensured no camelCase flags, we can now just:
-		// 1. Start with the command name
-		const args = [commandName];
-
-		// 3. Get positional arguments and explicit flags from the command line
-		const commandArgs = [];
-		const positionals = new Set(); // Track positional args we've seen
-
-		// Find the command in raw process.argv to extract args
-		const commandIndex = process.argv.indexOf(commandName);
-		if (commandIndex !== -1) {
-			// Process all args after the command name
-			for (let i = commandIndex + 1; i < process.argv.length; i++) {
-				const arg = process.argv[i];
-
-				if (arg.startsWith('--')) {
-					// It's a flag - pass through as is
-					commandArgs.push(arg);
-					// Skip the next arg if this is a flag with a value (not --flag=value format)
-					if (
-						!arg.includes('=') &&
-						i + 1 < process.argv.length &&
-						!process.argv[i + 1].startsWith('--')
-					) {
-						commandArgs.push(process.argv[++i]);
-					}
-				} else if (!positionals.has(arg)) {
-					// It's a positional argument we haven't seen
-					commandArgs.push(arg);
-					positionals.add(arg);
-				}
-			}
-		}
-
-		// Add all command line args we collected
-		args.push(...commandArgs);
-
-		// 4. Add default options from Commander if not specified on command line
-		// Track which options we've seen on the command line
-		const userOptions = new Set();
-		for (const arg of commandArgs) {
-			if (arg.startsWith('--')) {
-				// Extract option name (without -- and value)
-				const name = arg.split('=')[0].slice(2);
-				userOptions.add(name);
-
-				// Add the kebab-case version too, to prevent duplicates
-				const kebabName = name.replace(/([A-Z])/g, '-$1').toLowerCase();
-				userOptions.add(kebabName);
-
-				// Add the camelCase version as well
-				const camelName = kebabName.replace(/-([a-z])/g, (_, letter) =>
-					letter.toUpperCase()
-				);
-				userOptions.add(camelName);
-			}
-		}
-
-		// Add Commander-provided defaults for options not specified by user
-		Object.entries(options).forEach(([key, value]) => {
-			// Debug output to see what keys we're getting
-			if (process.env.DEBUG === '1') {
-				console.error(`DEBUG - Processing option: ${key} = ${value}`);
-			}
-
-			// Special case for numTasks > num-tasks (a known problem case)
-			if (key === 'numTasks') {
-				if (process.env.DEBUG === '1') {
-					console.error('DEBUG - Converting numTasks to num-tasks');
-				}
-				if (!userOptions.has('num-tasks') && !userOptions.has('numTasks')) {
-					args.push(`--num-tasks=${value}`);
-				}
-				return;
-			}
-
-			// Skip built-in Commander properties and options the user provided
-			if (
-				['parent', 'commands', 'options', 'rawArgs'].includes(key) ||
-				userOptions.has(key)
-			) {
-				return;
-			}
-
-			// Also check the kebab-case version of this key
-			const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
-			if (userOptions.has(kebabKey)) {
-				return;
-			}
-
-			// Add default values, using kebab-case for the parameter name
-			if (value !== undefined) {
-				if (typeof value === 'boolean') {
-					if (value === true) {
-						args.push(`--${kebabKey}`);
-					} else if (value === false && key === 'generate') {
-						args.push('--skip-generate');
-					}
-				} else {
-					// Always use kebab-case for option names
-					args.push(`--${kebabKey}=${value}`);
-				}
-			}
-		});
-
-		// Special handling for parent parameter (uses -p)
-		if (options.parent && !args.includes('-p') && !userOptions.has('parent')) {
-			args.push('-p', options.parent);
-		}
-
-		// Debug output for troubleshooting
-		if (process.env.DEBUG === '1') {
-			console.error('DEBUG - Command args:', commandArgs);
-			console.error('DEBUG - User options:', Array.from(userOptions));
-			console.error('DEBUG - Commander options:', options);
-			console.error('DEBUG - Final args:', args);
-		}
-
-		// Run the script with our processed args
-		runDevScript(args);
-	};
-}
-
-// // Special case for the 'init' command which uses a different script
-// function registerInitCommand(program) {
-// 	program
-// 		.command('init')
-// 		.description('Initialize a new project')
-// 		.option('-y, --yes', 'Skip prompts and use default values')
-// 		.option('-n, --name <name>', 'Project name')
-// 		.option('-d, --description <description>', 'Project description')
-// 		.option('-v, --version <version>', 'Project version')
-// 		.option('-a, --author <author>', 'Author name')
-// 		.option('--skip-install', 'Skip installing dependencies')
-// 		.option('--dry-run', 'Show what would be done without making changes')
-// 		.action((options) => {
-// 			// Pass through any options to the init script
-// 			const args = [
-// 				'--yes',
-// 				'name',
-// 				'description',
-// 				'version',
-// 				'author',
-// 				'skip-install',
-// 				'dry-run'
-// 			]
-// 				.filter((opt) => options[opt])
-// 				.map((opt) => {
-// 					if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
-// 						return `--${opt}`;
-// 					}
-// 					return `--${opt}=${options[opt]}`;
-// 				});
-
-// 			const child = spawn('node', [initScriptPath, ...args], {
-// 				stdio: 'inherit',
-// 				cwd: process.cwd()
-// 			});
-
-// 			child.on('close', (code) => {
-// 				process.exit(code);
-// 			});
-// 		});
-// }
-
-// Set up the command-line interface
-const program = new Command();
-
-program
-	.name('task-master')
-	.description('Claude Task Master CLI')
-	.version(version)
-	.addHelpText('afterAll', () => {
-		// Use the same help display function as dev.js for consistency
-		displayHelp();
-		return ''; // Return empty string to prevent commander's default help
-	});
-
-// Add custom help option to directly call our help display
-program.helpOption('-h, --help', 'Display help information');
-program.on('--help', () => {
-	displayHelp();
-});
-
-// // Add special case commands
-// registerInitCommand(program);
-
-program
-	.command('dev')
-	.description('Run the dev.js script')
-	.action(() => {
-		const args = process.argv.slice(process.argv.indexOf('dev') + 1);
-		runDevScript(args);
-	});
-
-// Use a temporary Command instance to get all command definitions
-const tempProgram = new Command();
-registerCommands(tempProgram);
-
-// For each command in the temp instance, add a modified version to our actual program
-tempProgram.commands.forEach((cmd) => {
-	if (['dev'].includes(cmd.name())) {
-		// Skip commands we've already defined specially
-		return;
-	}
-
-	// Create a new command with the same name and description
-	const newCmd = program.command(cmd.name()).description(cmd.description());
-
-	// Copy all options
-	cmd.options.forEach((opt) => {
-		newCmd.option(opt.flags, opt.description, opt.defaultValue);
-	});
-
-	// Set the action to proxy to dev.js
-	newCmd.action(createDevScriptAction(cmd.name()));
-});
-
-// Parse the command line arguments
-program.parse(process.argv);
-
-// Add global error handling for unknown commands and options
-process.on('uncaughtException', (err) => {
-	// Check if this is a commander.js unknown option error
-	if (err.code === 'commander.unknownOption') {
-		const option = err.message.match(/'([^']+)'/)?.[1];
-		const commandArg = process.argv.find(
-			(arg) =>
-				!arg.startsWith('-') &&
-				arg !== 'task-master' &&
-				!arg.includes('/') &&
-				arg !== 'node'
-		);
-		const command = commandArg || 'unknown';
-
-		console.error(chalk.red(`Error: Unknown option '${option}'`));
-		console.error(
-			chalk.yellow(
-				`Run 'task-master ${command} --help' to see available options for this command`
-			)
-		);
-		process.exit(1);
-	}
-
-	// Check if this is a commander.js unknown command error
-	if (err.code === 'commander.unknownCommand') {
-		const command = err.message.match(/'([^']+)'/)?.[1];
-
-		console.error(chalk.red(`Error: Unknown command '${command}'`));
-		console.error(
-			chalk.yellow(`Run 'task-master --help' to see available commands`)
-		);
-		process.exit(1);
-	}
-
-	// Handle other uncaught exceptions
-	console.error(chalk.red(`Error: ${err.message}`));
-	if (process.env.DEBUG === '1') {
-		console.error(err);
-	}
-	process.exit(1);
-});
-
-// Show help if no command was provided (just 'task-master' with no args)
-if (process.argv.length <= 2) {
-	displayBanner();
-	displayHelp();
-	process.exit(0);
-}
-
-// Add exports at the end of the file
-export { detectCamelCaseFlags };

package-lock.json

@@ -53,6 +53,8 @@
 				"jsonrepair": "^3.13.0",
 				"jsonwebtoken": "^9.0.2",
 				"lru-cache": "^10.2.0",
+				"marked": "^15.0.12",
+				"marked-terminal": "^7.3.0",
 				"ollama-ai-provider": "^1.2.0",
 				"openai": "^4.89.0",
 				"ora": "^8.2.0",
@@ -70,6 +72,7 @@
 				"@changesets/changelog-github": "^0.5.1",
 				"@changesets/cli": "^2.28.1",
 				"@types/jest": "^29.5.14",
+				"@types/marked-terminal": "^6.1.1",
 				"concurrently": "^9.2.1",
 				"cross-env": "^10.0.0",
 				"dotenv-mono": "^1.5.1",
@@ -10101,6 +10104,13 @@
 				"@babel/types": "^7.28.2"
 			}
 		},
+		"node_modules/@types/cardinal": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/@types/cardinal/-/cardinal-2.1.1.tgz",
+			"integrity": "sha512-/xCVwg8lWvahHsV2wXZt4i64H1sdL+sN1Uoq7fAc8/FA6uYHjuIveDwPwvGUYp4VZiv85dVl6J/Bum3NDAOm8g==",
+			"dev": true,
+			"license": "MIT"
+		},
 		"node_modules/@types/cors": {
 			"version": "2.8.19",
 			"resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
@@ -10261,6 +10271,32 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/@types/marked-terminal": {
+			"version": "6.1.1",
+			"resolved": "https://registry.npmjs.org/@types/marked-terminal/-/marked-terminal-6.1.1.tgz",
+			"integrity": "sha512-DfoUqkmFDCED7eBY9vFUhJ9fW8oZcMAK5EwRDQ9drjTbpQa+DnBTQQCwWhTFVf4WsZ6yYcJTI8D91wxTWXRZZQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/cardinal": "^2.1",
+				"@types/node": "*",
+				"chalk": "^5.3.0",
+				"marked": ">=6.0.0 <12"
+			}
+		},
+		"node_modules/@types/marked-terminal/node_modules/marked": {
+			"version": "11.2.0",
+			"resolved": "https://registry.npmjs.org/marked/-/marked-11.2.0.tgz",
+			"integrity": "sha512-HR0m3bvu0jAPYiIvLUUQtdg1g6D247//lvcekpHO1WMvbwDlwSkZAX9Lw4F4YHE1T0HaaNve0tuAWuV1UJ6vtw==",
+			"dev": true,
+			"license": "MIT",
+			"bin": {
+				"marked": "bin/marked.js"
+			},
+			"engines": {
+				"node": ">= 18"
+			}
+		},
 		"node_modules/@types/mdast": {
 			"version": "4.0.4",
 			"resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
@@ -12860,7 +12896,6 @@
 			"version": "1.0.2",
 			"resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
 			"integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=10"
@@ -14895,6 +14930,12 @@
 			"integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
 			"license": "MIT"
 		},
+		"node_modules/emojilib": {
+			"version": "2.4.0",
+			"resolved": "https://registry.npmjs.org/emojilib/-/emojilib-2.4.0.tgz",
+			"integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==",
+			"license": "MIT"
+		},
 		"node_modules/encodeurl": {
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
@@ -15064,7 +15105,6 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
 			"integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
-			"dev": true,
 			"license": "MIT",
 			"engines": {
 				"node": ">=18"
@@ -22303,7 +22343,6 @@
 			"resolved": "https://registry.npmjs.org/marked/-/marked-15.0.12.tgz",
 			"integrity": "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA==",
 			"license": "MIT",
-			"optional": true,
 			"bin": {
 				"marked": "bin/marked.js"
 			},
@@ -22311,6 +22350,54 @@
 				"node": ">= 18"
 			}
 		},
+		"node_modules/marked-terminal": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/marked-terminal/-/marked-terminal-7.3.0.tgz",
+			"integrity": "sha512-t4rBvPsHc57uE/2nJOLmMbZCQ4tgAccAED3ngXQqW6g+TxA488JzJ+FK3lQkzBQOI1mRV/r/Kq+1ZlJ4D0owQw==",
+			"license": "MIT",
+			"dependencies": {
+				"ansi-escapes": "^7.0.0",
+				"ansi-regex": "^6.1.0",
+				"chalk": "^5.4.1",
+				"cli-highlight": "^2.1.11",
+				"cli-table3": "^0.6.5",
+				"node-emoji": "^2.2.0",
+				"supports-hyperlinks": "^3.1.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			},
+			"peerDependencies": {
+				"marked": ">=1 <16"
+			}
+		},
+		"node_modules/marked-terminal/node_modules/ansi-escapes": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.1.0.tgz",
+			"integrity": "sha512-YdhtCd19sKRKfAAUsrcC1wzm4JuzJoiX4pOJqIoW2qmKj5WzG/dL8uUJ0361zaXtHqK7gEhOwtAtz7t3Yq3X5g==",
+			"license": "MIT",
+			"dependencies": {
+				"environment": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/marked-terminal/node_modules/ansi-regex": {
+			"version": "6.2.2",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+			"integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-regex?sponsor=1"
+			}
+		},
 		"node_modules/math-intrinsics": {
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -24134,6 +24221,33 @@
 				"node": ">=10.5.0"
 			}
 		},
+		"node_modules/node-emoji": {
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.2.0.tgz",
+			"integrity": "sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^4.6.0",
+				"char-regex": "^1.0.2",
+				"emojilib": "^2.4.0",
+				"skin-tone": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/node-emoji/node_modules/@sindresorhus/is": {
+			"version": "4.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+			"integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
 		"node_modules/node-fetch": {
 			"version": "2.7.0",
 			"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
@@ -27643,6 +27757,18 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/skin-tone": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
+			"integrity": "sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==",
+			"license": "MIT",
+			"dependencies": {
+				"unicode-emoji-modifier-base": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
 		"node_modules/slash": {
 			"version": "3.0.0",
 			"resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
@@ -28446,6 +28572,34 @@
 				"url": "https://github.com/chalk/supports-color?sponsor=1"
 			}
 		},
+		"node_modules/supports-hyperlinks": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-3.2.0.tgz",
+			"integrity": "sha512-zFObLMyZeEwzAoKCyu1B91U79K2t7ApXuQfo8OuxwXLDgcKxuwM+YvcbIhm6QWqz7mHUH1TVytR1PwVVjEuMig==",
+			"license": "MIT",
+			"dependencies": {
+				"has-flag": "^4.0.0",
+				"supports-color": "^7.0.0"
+			},
+			"engines": {
+				"node": ">=14.18"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/supports-hyperlinks?sponsor=1"
+			}
+		},
+		"node_modules/supports-hyperlinks/node_modules/supports-color": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+			"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+			"license": "MIT",
+			"dependencies": {
+				"has-flag": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
 		"node_modules/supports-preserve-symlinks-flag": {
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
@@ -29435,6 +29589,15 @@
 			"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
 			"license": "MIT"
 		},
+		"node_modules/unicode-emoji-modifier-base": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
+			"integrity": "sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=4"
+			}
+		},
 		"node_modules/unicorn-magic": {
 			"version": "0.3.0",
 			"resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",

package.json

@@ -12,7 +12,7 @@
 	"workspaces": ["apps/*", "packages/*", "."],
 	"scripts": {
 		"build": "npm run build:build-config && tsup",
-		"dev": "tsup --watch",
+		"dev": "tsup --watch='packages/*/src/**/*' --watch='apps/cli/src/**/*' --watch='bin/**/*' --watch='mcp-server/**/*'",
 		"turbo:dev": "turbo dev",
 		"turbo:build": "turbo build",
 		"turbo:typecheck": "turbo typecheck",
@@ -59,7 +59,6 @@
 	"license": "MIT WITH Commons-Clause",
 	"dependencies": {
 		"@ai-sdk/amazon-bedrock": "^2.2.9",
-		"@tm/cli": "*",
 		"@ai-sdk/anthropic": "^1.2.10",
 		"@ai-sdk/azure": "^1.3.17",
 		"@ai-sdk/google": "^1.2.13",
@@ -74,6 +73,7 @@
 		"@inquirer/search": "^3.0.15",
 		"@openrouter/ai-sdk-provider": "^0.4.5",
 		"@streamparser/json": "^0.0.22",
+		"@tm/cli": "*",
 		"ai": "^4.3.10",
 		"ajv": "^8.17.1",
 		"ajv-formats": "^3.0.1",
@@ -97,6 +97,8 @@
 		"jsonrepair": "^3.13.0",
 		"jsonwebtoken": "^9.0.2",
 		"lru-cache": "^10.2.0",
+		"marked": "^15.0.12",
+		"marked-terminal": "^7.3.0",
 		"ollama-ai-provider": "^1.2.0",
 		"openai": "^4.89.0",
 		"ora": "^8.2.0",
@@ -131,6 +133,7 @@
 		"@changesets/changelog-github": "^0.5.1",
 		"@changesets/cli": "^2.28.1",
 		"@types/jest": "^29.5.14",
+		"@types/marked-terminal": "^6.1.1",
 		"concurrently": "^9.2.1",
 		"cross-env": "^10.0.0",
 		"dotenv-mono": "^1.5.1",

packages/tm-core/package.json

@@ -7,54 +7,19 @@
 	"types": "./src/index.ts",
 	"main": "./dist/index.js",
 	"exports": {
-		".": {
+		".": "./src/index.ts",
-			"types": "./src/index.ts",
+		"./auth": "./src/auth/index.ts",
-			"import": "./dist/index.js"
+		"./storage": "./src/storage/index.ts",
-		},
+		"./config": "./src/config/index.ts",
-		"./auth": {
+		"./providers": "./src/providers/index.ts",
-			"types": "./src/auth/index.ts",
+		"./services": "./src/services/index.ts",
-			"import": "./dist/auth/index.js"
+		"./errors": "./src/errors/index.ts",
-		},
+		"./logger": "./src/logger/index.ts",
-		"./storage": {
+		"./types": "./src/types/index.ts",
-			"types": "./src/storage/index.ts",
+		"./interfaces": "./src/interfaces/index.ts",
-			"import": "./dist/storage/index.js"
+		"./utils": "./src/utils/index.ts"
-		},
-		"./config": {
-			"types": "./src/config/index.ts",
-			"import": "./dist/config/index.js"
-		},
-		"./providers": {
-			"types": "./src/providers/index.ts",
-			"import": "./dist/providers/index.js"
-		},
-		"./services": {
-			"types": "./src/services/index.ts",
-			"import": "./dist/services/index.js"
-		},
-		"./errors": {
-			"types": "./src/errors/index.ts",
-			"import": "./dist/errors/index.js"
-		},
-		"./logger": {
-			"types": "./src/logger/index.ts",
-			"import": "./dist/logger/index.js"
-		},
-		"./types": {
-			"types": "./src/types/index.ts",
-			"import": "./dist/types/index.js"
-		},
-		"./interfaces": {
-			"types": "./src/interfaces/index.ts",
-			"import": "./dist/interfaces/index.js"
-		},
-		"./utils": {
-			"types": "./src/utils/index.ts",
-			"import": "./dist/utils/index.js"
-		}
 	},
 	"scripts": {
-		"build": "tsup",
-		"dev": "tsup --watch",
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"test:coverage": "vitest run --coverage",

packages/tm-core/tsup.config.ts

@@ -1,41 +0,0 @@
-import { defineConfig } from 'tsup';
-import { baseConfig, mergeConfig } from '@tm/build-config';
-import { load as dotenvLoad } from 'dotenv-mono';
-
-dotenvLoad();
-
-// Get all TM_PUBLIC_* env variables for build-time injection
-const getBuildTimeEnvs = () => {
-	const envs: Record<string, string> = {};
-	for (const [key, value] of Object.entries(process.env)) {
-		if (key.startsWith('TM_PUBLIC_')) {
-			// Return the actual value, not JSON.stringify'd
-			envs[key] = value || '';
-		}
-	}
-	return envs;
-};
-
-export default defineConfig(
-	mergeConfig(baseConfig, {
-		entry: {
-			index: 'src/index.ts',
-			'auth/index': 'src/auth/index.ts',
-			'config/index': 'src/config/index.ts',
-			'errors/index': 'src/errors/index.ts',
-			'interfaces/index': 'src/interfaces/index.ts',
-			'logger/index': 'src/logger/index.ts',
-			'parser/index': 'src/parser/index.ts',
-			'providers/index': 'src/providers/index.ts',
-			'services/index': 'src/services/index.ts',
-			'storage/index': 'src/storage/index.ts',
-			'types/index': 'src/types/index.ts',
-			'utils/index': 'src/utils/index.ts'
-		},
-		format: ['esm'],
-		dts: true,
-		outDir: 'dist',
-		// Replace process.env.TM_PUBLIC_* with actual values at build time
-		env: getBuildTimeEnvs()
-	})
-);

src/utils/getVersion.js

@@ -1,7 +1,4 @@
-import fs from 'fs';
+import packageJson from '../../package.json' with { type: 'json' };
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { log } from '../../scripts/modules/utils.js';
 
 /**
  * Reads the version from the nearest package.json relative to this file.
@@ -9,27 +6,5 @@ import { log } from '../../scripts/modules/utils.js';
  * @returns {string} The version string or 'unknown'.
  */
 export function getTaskMasterVersion() {
-	let version = 'unknown';
+	return packageJson.version || 'unknown';
-	try {
-		// Get the directory of the current module (getPackageVersion.js)
-		const currentModuleFilename = fileURLToPath(import.meta.url);
-		const currentModuleDirname = path.dirname(currentModuleFilename);
-		// Construct the path to package.json relative to this file (../../package.json)
-		const packageJsonPath = path.join(
-			currentModuleDirname,
-			'..',
-			'..',
-			'package.json'
-		);
-
-		if (fs.existsSync(packageJsonPath)) {
-			const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
-			const packageJson = JSON.parse(packageJsonContent);
-			version = packageJson.version;
-		}
-	} catch (error) {
-		// Silently fall back to default version
-		log('warn', 'Could not read own package.json for version info.', error);
-	}
-	return version;
 }

tsconfig.json

@@ -12,7 +12,15 @@
 		"strict": true,
 		"skipLibCheck": true,
 		"noEmit": true,
-		"baseUrl": "."
+		"baseUrl": ".",
+		"paths": {
+			"@tm/core": ["./packages/tm-core/src/index.ts"],
+			"@tm/core/*": ["./packages/tm-core/src/*"],
+			"@tm/cli": ["./apps/cli/src/index.ts"],
+			"@tm/cli/*": ["./apps/cli/src/*"],
+			"@tm/build-config": ["./packages/build-config/src/index.ts"],
+			"@tm/build-config/*": ["./packages/build-config/src/*"]
+		}
 	},
 	"tsx": {
 		"tsconfig": {

tsup.config.ts

@@ -1,26 +1,97 @@
 import { defineConfig } from 'tsup';
 import { baseConfig, mergeConfig } from '@tm/build-config';
+import { load as dotenvLoad } from 'dotenv-mono';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+dotenvLoad();
+
+// Get all TM_PUBLIC_* env variables for build-time injection
+const getBuildTimeEnvs = () => {
+	const envs: Record<string, string> = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (key.startsWith('TM_PUBLIC_')) {
+			// Return the actual value, not JSON.stringify'd
+			envs[key] = value || '';
+		}
+	}
+	return envs;
+};
 
 export default defineConfig(
 	mergeConfig(baseConfig, {
 		entry: {
-			'task-master': 'bin/task-master.js',
+			'task-master': 'scripts/dev.js',
 			'mcp-server': 'mcp-server/server.js'
 		},
 		outDir: 'dist',
 		publicDir: 'public',
-		// Bundle our monorepo packages but keep node_modules external
+		// Override the base config's external to bundle our workspace packages
-		noExternal: [/@tm\/.*/],
+		noExternal: [/^@tm\//],
-		// Ensure no code splitting
+		external: [
-		splitting: false,
+			/^@supabase\//, // Keep Supabase external to avoid dynamic require issues
-		// Better watch configuration
+			'marked',
-		ignoreWatch: [
+			'marked-terminal'
-			'dist',
+		],
-			'node_modules',
+		env: getBuildTimeEnvs(),
-			'.git',
+		esbuildOptions(options) {
-			'tests',
+			// Set up path aliases for workspace packages
-			'*.test.*',
+			options.alias = {
-			'*.spec.*'
+				'@tm/core': path.resolve(__dirname, 'packages/tm-core/src/index.ts'),
-		]
+				'@tm/core/auth': path.resolve(
+					__dirname,
+					'packages/tm-core/src/auth/index.ts'
+				),
+				'@tm/core/storage': path.resolve(
+					__dirname,
+					'packages/tm-core/src/storage/index.ts'
+				),
+				'@tm/core/config': path.resolve(
+					__dirname,
+					'packages/tm-core/src/config/index.ts'
+				),
+				'@tm/core/providers': path.resolve(
+					__dirname,
+					'packages/tm-core/src/providers/index.ts'
+				),
+				'@tm/core/services': path.resolve(
+					__dirname,
+					'packages/tm-core/src/services/index.ts'
+				),
+				'@tm/core/errors': path.resolve(
+					__dirname,
+					'packages/tm-core/src/errors/index.ts'
+				),
+				'@tm/core/logger': path.resolve(
+					__dirname,
+					'packages/tm-core/src/logger/index.ts'
+				),
+				'@tm/core/types': path.resolve(
+					__dirname,
+					'packages/tm-core/src/types/index.ts'
+				),
+				'@tm/core/interfaces': path.resolve(
+					__dirname,
+					'packages/tm-core/src/interfaces/index.ts'
+				),
+				'@tm/core/utils': path.resolve(
+					__dirname,
+					'packages/tm-core/src/utils/index.ts'
+				),
+				'@tm/cli': path.resolve(__dirname, 'apps/cli/src/index.ts'),
+				'@tm/cli/commands': path.resolve(
+					__dirname,
+					'apps/cli/src/commands/index.ts'
+				),
+				'@tm/cli/utils': path.resolve(__dirname, 'apps/cli/src/utils/index.ts'),
+				'@tm/cli/ui': path.resolve(__dirname, 'apps/cli/src/ui/index.ts'),
+				'@tm/build-config': path.resolve(
+					__dirname,
+					'packages/build-config/src/tsup.base.ts'
+				)
+			};
+		}
 	})
 );

turbo.json

@@ -10,7 +10,6 @@
 		"dev": {
 			"cache": false,
 			"persistent": true,
-			"dependsOn": ["^build"],
 			"inputs": [
 				"$TURBO_DEFAULT$",
 				"!{packages,apps}/**/dist/**",