backlog.md 0.1.0

package/src/test/parent-id-normalization.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Core } from "../index.ts";
+import type { Task } from "../types/index.ts";
+
+const TEST_DIR = join(process.cwd(), "test-parent-normalization");
+const CLI_PATH = join(process.cwd(), "src", "cli.ts");
+
+async function initGitRepo(dir: string) {
+	await Bun.spawn(["git", "init"], { cwd: dir }).exited;
+	await Bun.spawn(["git", "config", "user.name", "Test User"], { cwd: dir }).exited;
+	await Bun.spawn(["git", "config", "user.email", "test@example.com"], { cwd: dir }).exited;
+}
+
+describe("CLI parent task id normalization", () => {
+	beforeEach(async () => {
+		await rm(TEST_DIR, { recursive: true, force: true }).catch(() => {});
+		await mkdir(TEST_DIR, { recursive: true });
+		await initGitRepo(TEST_DIR);
+	});
+
+	afterEach(async () => {
+		await rm(TEST_DIR, { recursive: true, force: true }).catch(() => {});
+	});
+
+	it("should normalize parent task id when creating subtasks", async () => {
+		const core = new Core(TEST_DIR);
+		await core.initializeProject("Normalization Test");
+
+		const parent: Task = {
+			id: "task-4",
+			title: "Parent",
+			status: "To Do",
+			assignee: [],
+			createdDate: "2025-06-08",
+			labels: [],
+			dependencies: [],
+			description: "",
+		};
+		await core.createTask(parent, true);
+
+		await Bun.spawn(["bun", "run", CLI_PATH, "task", "create", "Child", "--parent", "4"], { cwd: TEST_DIR }).exited;
+
+		const child = await core.filesystem.loadTask("task-4.1");
+		expect(child?.parentTaskId).toBe("task-4");
+	});
+});

package/src/test/remote-id-conflict.test.ts

@@ -0,0 +1,60 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Core } from "../index.ts";
+
+const TEST_DIR = join(process.cwd(), "test-remote-id");
+const REMOTE_DIR = join(TEST_DIR, "remote.git");
+const LOCAL_DIR = join(TEST_DIR, "local");
+const CLI_PATH = join(process.cwd(), "src", "cli.ts");
+
+async function initRepo(dir: string) {
+	await Bun.spawn(["git", "init"], { cwd: dir }).exited;
+	await Bun.spawn(["git", "config", "user.name", "Test"], { cwd: dir }).exited;
+	await Bun.spawn(["git", "config", "user.email", "test@example.com"], { cwd: dir }).exited;
+}
+
+describe("next id across remote branches", () => {
+	beforeAll(async () => {
+		await rm(TEST_DIR, { recursive: true, force: true }).catch(() => {});
+		await mkdir(REMOTE_DIR, { recursive: true });
+		await Bun.spawn(["git", "init", "--bare"], { cwd: REMOTE_DIR }).exited;
+		await mkdir(LOCAL_DIR, { recursive: true });
+		await initRepo(LOCAL_DIR);
+		await Bun.spawn(["git", "remote", "add", "origin", REMOTE_DIR], { cwd: LOCAL_DIR }).exited;
+
+		const core = new Core(LOCAL_DIR);
+		await core.initializeProject("Remote Test");
+		await Bun.spawn(["git", "branch", "-M", "main"], { cwd: LOCAL_DIR }).exited;
+		await Bun.spawn(["git", "push", "-u", "origin", "main"], { cwd: LOCAL_DIR }).exited;
+
+		await Bun.spawn(["git", "checkout", "-b", "feature"], { cwd: LOCAL_DIR }).exited;
+		await core.createTask(
+			{
+				id: "task-1",
+				title: "Remote Task",
+				status: "To Do",
+				assignee: [],
+				createdDate: "2025-06-08",
+				labels: [],
+				dependencies: [],
+				description: "",
+			},
+			true,
+		);
+		await Bun.spawn(["git", "push", "-u", "origin", "feature"], { cwd: LOCAL_DIR }).exited;
+		await Bun.spawn(["git", "checkout", "main"], { cwd: LOCAL_DIR }).exited;
+	});
+
+	afterAll(async () => {
+		await rm(TEST_DIR, { recursive: true, force: true }).catch(() => {});
+	});
+
+	it("uses id after highest remote task", async () => {
+		const result = Bun.spawnSync(["bun", "run", CLI_PATH, "task", "create", "Local Task"], { cwd: LOCAL_DIR });
+		expect(result.stdout.toString()).toContain("Created task task-2");
+		const core = new Core(LOCAL_DIR);
+		const task = await core.filesystem.loadTask("task-2");
+		expect(task).not.toBeNull();
+	});
+});

package/src/test/status-icon.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import { formatStatusWithIcon, getStatusColor, getStatusIcon, getStatusStyle } from "../ui/status-icon.ts";
+
+describe("Status Icon Component", () => {
+	describe("getStatusStyle", () => {
+		test("returns correct style for Done status", () => {
+			const style = getStatusStyle("Done");
+			expect(style.icon).toBe("✔");
+			expect(style.color).toBe("green");
+		});
+
+		test("returns correct style for In Progress status", () => {
+			const style = getStatusStyle("In Progress");
+			expect(style.icon).toBe("◒");
+			expect(style.color).toBe("yellow");
+		});
+
+		test("returns correct style for Blocked status", () => {
+			const style = getStatusStyle("Blocked");
+			expect(style.icon).toBe("●");
+			expect(style.color).toBe("red");
+		});
+
+		test("returns correct style for To Do status", () => {
+			const style = getStatusStyle("To Do");
+			expect(style.icon).toBe("○");
+			expect(style.color).toBe("white");
+		});
+
+		test("returns correct style for Review status", () => {
+			const style = getStatusStyle("Review");
+			expect(style.icon).toBe("◆");
+			expect(style.color).toBe("blue");
+		});
+
+		test("returns correct style for Testing status", () => {
+			const style = getStatusStyle("Testing");
+			expect(style.icon).toBe("▣");
+			expect(style.color).toBe("cyan");
+		});
+
+		test("returns default style for unknown status", () => {
+			const style = getStatusStyle("Unknown Status");
+			expect(style.icon).toBe("○");
+			expect(style.color).toBe("white");
+		});
+	});
+
+	describe("getStatusColor", () => {
+		test("returns correct color for each status", () => {
+			expect(getStatusColor("Done")).toBe("green");
+			expect(getStatusColor("In Progress")).toBe("yellow");
+			expect(getStatusColor("Blocked")).toBe("red");
+			expect(getStatusColor("To Do")).toBe("white");
+			expect(getStatusColor("Review")).toBe("blue");
+			expect(getStatusColor("Testing")).toBe("cyan");
+		});
+
+		test("returns default color for unknown status", () => {
+			expect(getStatusColor("Unknown")).toBe("white");
+		});
+	});
+
+	describe("getStatusIcon", () => {
+		test("returns correct icon for each status", () => {
+			expect(getStatusIcon("Done")).toBe("✔");
+			expect(getStatusIcon("In Progress")).toBe("◒");
+			expect(getStatusIcon("Blocked")).toBe("●");
+			expect(getStatusIcon("To Do")).toBe("○");
+			expect(getStatusIcon("Review")).toBe("◆");
+			expect(getStatusIcon("Testing")).toBe("▣");
+		});
+
+		test("returns default icon for unknown status", () => {
+			expect(getStatusIcon("Unknown")).toBe("○");
+		});
+	});
+
+	describe("formatStatusWithIcon", () => {
+		test("formats status with correct icon", () => {
+			expect(formatStatusWithIcon("Done")).toBe("✔ Done");
+			expect(formatStatusWithIcon("In Progress")).toBe("◒ In Progress");
+			expect(formatStatusWithIcon("Blocked")).toBe("● Blocked");
+			expect(formatStatusWithIcon("To Do")).toBe("○ To Do");
+			expect(formatStatusWithIcon("Review")).toBe("◆ Review");
+			expect(formatStatusWithIcon("Testing")).toBe("▣ Testing");
+		});
+
+		test("formats unknown status with default icon", () => {
+			expect(formatStatusWithIcon("Custom Status")).toBe("○ Custom Status");
+		});
+	});
+});

package/src/types/blessed.d.ts

@@ -0,0 +1,14 @@
+// Minimal declaration to satisfy TypeScript when importing "bblessed".
+// The actual library is dynamically imported at runtime. We only need the
+// "any" type shape to avoid compile-time errors when the package is not
+// present during type checking.
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare module "blessed" {
+	// We intentionally use the most permissive type to keep the shim minimal.
+	// Downstream code performs runtime feature detection and falls back to a
+	// non-TUI implementation when the real library cannot be resolved.
+	// biome-ignore lint/suspicious/noExplicitAny: blessed types are complex
+	const blessed: any;
+	export = blessed;
+}

package/src/types/index.ts

@@ -0,0 +1,55 @@
+export interface Task {
+	id: string;
+	title: string;
+	status: string;
+	assignee: string[];
+	reporter?: string;
+	createdDate: string;
+	updatedDate?: string;
+	labels: string[];
+	milestone?: string;
+	dependencies: string[];
+	description: string;
+	acceptanceCriteria?: string[];
+	parentTaskId?: string;
+	subtasks?: string[];
+}
+
+export interface DecisionLog {
+	id: string;
+	title: string;
+	date: string;
+	status: "proposed" | "accepted" | "rejected" | "superseded";
+	context: string;
+	decision: string;
+	consequences: string;
+	alternatives?: string;
+}
+
+export interface Document {
+	id: string;
+	title: string;
+	type: "readme" | "guide" | "specification" | "other";
+	createdDate: string;
+	updatedDate?: string;
+	content: string;
+	tags?: string[];
+}
+
+export interface BacklogConfig {
+	projectName: string;
+	defaultAssignee?: string;
+	defaultReporter?: string;
+	statuses: string[];
+	labels: string[];
+	milestones: string[];
+	defaultStatus?: string;
+	dateFormat: string;
+	maxColumnWidth?: number;
+	taskResolutionStrategy?: "most_recent" | "most_progressed";
+}
+
+export interface ParsedMarkdown {
+	frontmatter: Record<string, unknown>;
+	content: string;
+}

package/src/types/raw.d.ts

@@ -0,0 +1,4 @@
+declare module "*.md?raw" {
+	const content: string;
+	export default content;
+}

package/src/ui/board.ts

@@ -0,0 +1,322 @@
+/* Kanban board renderer for the bblessed TUI. */
+
+import { createRequire } from "node:module";
+import { join } from "node:path";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { stdin as input, stdout as output } from "node:process";
+import { type BoardLayout, compareIds, generateKanbanBoard } from "../board.ts";
+import { Core } from "../core/backlog.ts";
+import type { Task } from "../types/index.ts";
+import { formatStatusWithIcon, getStatusColor, getStatusIcon } from "./status-icon.ts";
+import { createTaskPopup } from "./task-viewer.ts";
+
+// Load blessed dynamically
+// biome-ignore lint/suspicious/noExplicitAny: blessed is dynamically loaded
+async function loadBlessed(): Promise<any | null> {
+	// Don't check TTY in Bun - let blessed handle it
+	try {
+		// Try using createRequire for better compatibility
+		const require = createRequire(import.meta.url);
+		const blessed = require("blessed");
+		return blessed;
+	} catch {
+		try {
+			// Fallback to dynamic import
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore — module may not exist at runtime.
+			const mod = await import("blessed");
+			return mod.default ?? mod;
+		} catch {
+			// Blessed may not work in bundled executables
+			return null;
+		}
+	}
+}
+
+/**
+ * Render the provided tasks in a TUI.  Falls back to plain text when the
+ * terminal UI cannot be initialized.
+ */
+export async function renderBoardTui(
+	tasks: Task[],
+	statuses: string[],
+	layout: BoardLayout,
+	maxColumnWidth: number,
+): Promise<void> {
+	const blessed = await loadBlessed();
+	if (!blessed) {
+		// Fallback to ASCII board
+		const boardStr = generateKanbanBoard(tasks, statuses, layout, maxColumnWidth);
+		console.log(boardStr);
+		return;
+	}
+
+	// Group tasks by status
+	const tasksByStatus = new Map<string, Task[]>();
+	for (const status of statuses) {
+		tasksByStatus.set(status, []);
+	}
+	for (const task of tasks) {
+		const status = task.status || "";
+		if (!tasksByStatus.has(status)) {
+			tasksByStatus.set(status, []);
+		}
+		const statusTasks = tasksByStatus.get(status);
+		if (statusTasks) {
+			statusTasks.push(task);
+		}
+	}
+
+	// Filter out empty statuses
+	const nonEmptyStatuses = statuses.filter((status) => {
+		const tasks = tasksByStatus.get(status);
+		return tasks && tasks.length > 0;
+	});
+
+	// If no columns have tasks, show a message
+	if (nonEmptyStatuses.length === 0) {
+		console.log("No tasks found in any status.");
+		return;
+	}
+
+	return new Promise<void>((resolve) => {
+		const screen = blessed.screen({
+			smartCSR: true,
+			title: "Backlog Board View",
+		});
+
+		// Create container for the board
+		const container = blessed.box({
+			parent: screen,
+			width: "100%",
+			height: "100%",
+		});
+
+		// Calculate column dimensions
+		const columnCount = nonEmptyStatuses.length || 1;
+		const columnWidth = Math.floor(100 / columnCount);
+
+		// Create columns
+		// biome-ignore lint/suspicious/noExplicitAny: blessed column structure
+		const columns: any[] = [];
+
+		nonEmptyStatuses.forEach((status, index) => {
+			// Calculate exact position for each column
+			const left = index * columnWidth;
+			const isLast = index === nonEmptyStatuses.length - 1;
+
+			// For the last column, extend to the right edge to avoid gaps
+			const width = isLast ? `${100 - left}%` : `${columnWidth}%`;
+
+			// Column container
+			const column = blessed.box({
+				parent: container,
+				left: `${left}%`,
+				top: 0,
+				width,
+				height: "100%-1", // Leave space for footer
+				border: {
+					type: "line",
+				},
+				style: {
+					border: {
+						fg: "gray",
+					},
+				},
+				label: ` ${getStatusIcon(status)} ${status || "No Status"} (${tasksByStatus.get(status)?.length || 0}) `,
+			});
+
+			// Task list for this column
+			const taskList = blessed.list({
+				parent: column,
+				top: 1, // Start below the border
+				left: 1, // Start after the border
+				width: "100%-4", // Account for borders and padding
+				height: "100%-3", // Account for borders
+				items: [],
+				keys: false, // Disable built-in key handling
+				vi: false,
+				mouse: true,
+				scrollable: true,
+				alwaysScroll: false,
+				selectedBg: undefined, // Don't show selection by default
+				style: {
+					selected: {
+						bg: undefined, // Initially no background
+						fg: "white",
+					},
+				},
+				tags: true, // Enable tag parsing for colors
+			});
+
+			// Populate tasks with enhanced styling
+			const tasksInStatus = (tasksByStatus.get(status) || []).sort(compareIds);
+			const items = tasksInStatus.map((task) => {
+				const assigneeText = task.assignee?.length
+					? ` {cyan-fg}${task.assignee[0].startsWith("@") ? task.assignee[0] : `@${task.assignee[0]}`}{/}`
+					: "";
+				const labelsText = task.labels?.length ? ` {yellow-fg}[${task.labels.join(", ")}]{/}` : "";
+
+				return `{bold}${task.id}{/bold} - ${task.title}${assigneeText}${labelsText}`;
+			});
+			taskList.setItems(items);
+
+			// Store reference for navigation
+			columns.push({ box: column, list: taskList, status, tasks: tasksInStatus });
+		});
+
+		// Current column index and popup state
+		let currentColumn = 0;
+		let isPopupOpen = false;
+
+		if (columns.length > 0) {
+			columns[currentColumn].list.focus();
+			columns[currentColumn].list.select(0);
+			// Only show selection on the active column
+			columns[currentColumn].list.style.selected.bg = "blue";
+		}
+
+		// Helper function to switch columns
+		const switchToColumn = (newColumn: number) => {
+			// Don't allow navigation while popup is open
+			if (isPopupOpen) return;
+
+			if (newColumn >= 0 && newColumn < columns.length && newColumn !== currentColumn) {
+				// Remember current selection index
+				const currentIndex = columns[currentColumn].list.selected || 0;
+
+				// Unfocus current column
+				columns[currentColumn].list.style.selected.bg = undefined;
+				columns[currentColumn].list.screen.render();
+
+				// Focus new column
+				currentColumn = newColumn;
+				const newList = columns[currentColumn].list;
+				newList.focus();
+				newList.style.selected.bg = "blue";
+
+				// Set selection to same index or last item if fewer items
+				const newIndex = Math.min(currentIndex, newList.items.length - 1);
+				newList.select(Math.max(0, newIndex));
+
+				screen.render();
+			}
+		};
+
+		// Navigation between columns
+		screen.key(["left", "h"], () => {
+			switchToColumn(currentColumn - 1);
+		});
+
+		screen.key(["right", "l"], () => {
+			switchToColumn(currentColumn + 1);
+		});
+
+		// Up/down navigation within column
+		screen.key(["up", "k"], () => {
+			// Don't allow navigation while popup is open
+			if (isPopupOpen) return;
+
+			const list = columns[currentColumn].list;
+			const selected = list.selected || 0;
+			if (selected > 0) {
+				list.select(selected - 1);
+				screen.render();
+			}
+		});
+
+		screen.key(["down", "j"], () => {
+			// Don't allow navigation while popup is open
+			if (isPopupOpen) return;
+
+			const list = columns[currentColumn].list;
+			const selected = list.selected || 0;
+			if (selected < list.items.length - 1) {
+				list.select(selected + 1);
+				screen.render();
+			}
+		});
+
+		// Show task details on enter
+		screen.key(["enter"], async () => {
+			// Don't allow opening multiple popups
+			if (isPopupOpen) return;
+
+			const column = columns[currentColumn];
+			const selected = column.list.selected;
+			if (selected >= 0 && selected < column.tasks.length) {
+				const task = column.tasks[selected];
+				isPopupOpen = true;
+
+				// Load task content
+				let content = "";
+				try {
+					const core = new Core(process.cwd());
+					const files = await Array.fromAsync(new Bun.Glob("*.md").scan({ cwd: core.filesystem.tasksDir }));
+					const taskFile = files.find((f) => f.startsWith(`${task.id} -`));
+					if (taskFile) {
+						const filePath = join(core.filesystem.tasksDir, taskFile);
+						content = await Bun.file(filePath).text();
+					}
+				} catch (error) {
+					// Use task data if file cannot be loaded
+					content = "";
+				}
+
+				// Create enhanced popup
+				const popupData = await createTaskPopup(screen, task, content);
+				if (!popupData) {
+					isPopupOpen = false;
+					return;
+				}
+
+				const { popup, contentArea, close } = popupData;
+
+				// Add escape handler directly to the focused content area
+				contentArea.key(["escape", "q"], () => {
+					isPopupOpen = false;
+					close();
+					columns[currentColumn].list.focus();
+				});
+
+				screen.render();
+			}
+		});
+
+		// Footer hint line
+		const helpText = blessed.box({
+			parent: screen,
+			bottom: 0,
+			left: 0,
+			width: "100%",
+			height: 1,
+			border: "line",
+			content: " ←/→ columns · ↑/↓ tasks · Enter view details · q/Esc quit ",
+			style: {
+				fg: "gray",
+				border: { fg: "gray" },
+			},
+		});
+
+		// Exit keys - only when no popup is active
+		screen.key(["q", "C-c"], () => {
+			screen.destroy();
+			resolve();
+		});
+
+		// Global escape handler - only exit if no popup is active
+		screen.key(["escape"], () => {
+			// Check if any popup is currently displayed
+			const hasPopup = screen.children.some(
+				// biome-ignore lint/suspicious/noExplicitAny: blessed types are complex
+				(child: any) => child !== container && child !== helpText && child.visible !== false,
+			);
+			if (!hasPopup) {
+				screen.destroy();
+				resolve();
+			}
+		});
+
+		screen.render();
+	});
+}