ccdock 0.1.0

package/src/sidebar.ts

@@ -0,0 +1,556 @@
+import { randomUUID } from "node:crypto";
+import { loadConfig } from "./config/config.ts";
+import { CURSOR_HIDE, CURSOR_SHOW } from "./tui/ansi.ts";
+import {
+	repositionAllEditors,
+	closeAllEditors,
+	closeEditorWindow,
+	listEditorWindows,
+	getFocusedEditorWindow,
+} from "./workspace/window.ts";
+import { disableRawMode, enableRawMode, parseKey, parseKeyWizard } from "./tui/input.ts";
+import { renderSidebar } from "./tui/render.ts";
+import { renderWizard } from "./tui/wizard.ts";
+import type { RepoInfo, SidebarState } from "./types.ts";
+import { focusEditor, openEditor } from "./workspace/editor.ts";
+import {
+	cleanStaleAgents,
+	deleteSession,
+	loadAgentStates,
+	loadSessions,
+	saveSession,
+} from "./workspace/state.ts";
+import { createWorktree, listWorktrees, removeWorktree } from "./worktree/manager.ts";
+import { scanRepos } from "./worktree/scanner.ts";
+
+function sessionNameFromBranch(branchName: string): string {
+	const parts = branchName.split("/");
+	return parts[parts.length - 1] ?? branchName;
+}
+
+function createInitialState(): SidebarState {
+	const [rows, cols] = [process.stdout.rows ?? 24, process.stdout.columns ?? 80];
+	return {
+		sessions: [],
+		selectedIndex: 0,
+		rows,
+		cols,
+		animationFrame: 0,
+		compactMode: false,
+		showActivityLog: false,
+		cardRowRanges: [],
+		activityLog: [],
+		wizard: null,
+		deleteConfirm: null,
+		quitConfirm: null,
+	};
+}
+
+async function refreshSessions(state: SidebarState): Promise<void> {
+	const sessions = loadSessions();
+	const agentStates = loadAgentStates();
+
+	// Match agent states to sessions by cwd prefix
+	for (const session of sessions) {
+		session.agents = agentStates.filter(
+			(a) => a.cwd.startsWith(session.worktreePath) || a.sessionId === session.id,
+		);
+	}
+
+	// Detect editor window state for each session
+	const [editorWindows, focusedEditor] = await Promise.all([
+		listEditorWindows(),
+		getFocusedEditorWindow(),
+	]);
+
+	for (const session of sessions) {
+		const basename = session.worktreePath.split("/").pop() ?? "";
+		const hasWindow = editorWindows.some((w) => w.includes(basename));
+		if (hasWindow && focusedEditor.isFrontmost && focusedEditor.frontWindow.includes(basename)) {
+			session.editorState = "focused";
+		} else if (hasWindow) {
+			session.editorState = "open";
+		} else {
+			session.editorState = "closed";
+		}
+	}
+
+	state.sessions = sessions;
+
+	// Keep selectedIndex in bounds
+	if (state.selectedIndex >= state.sessions.length) {
+		state.selectedIndex = Math.max(0, state.sessions.length - 1);
+	}
+
+	// Update activity log from agents
+	for (const agent of agentStates) {
+		if (agent.toolName && agent.status === "running") {
+			const time = new Date(agent.updatedAt).toLocaleTimeString("en-US", {
+				hour12: false,
+				hour: "2-digit",
+				minute: "2-digit",
+				second: "2-digit",
+			});
+			const sessionIdx = sessions.findIndex(
+				(s) => agent.cwd.startsWith(s.worktreePath) || agent.sessionId === s.id,
+			);
+			// Only add if not duplicate of last entry
+			const lastEntry = state.activityLog[state.activityLog.length - 1];
+			const toolKey = `${agent.toolName}:${agent.toolDetail}`;
+			if (!lastEntry || lastEntry.time !== time || lastEntry.tool !== toolKey) {
+				state.activityLog.push({
+					time,
+					sessionId: agent.sessionId,
+					sessionIndex: sessionIdx,
+					agent: agent.agentType,
+					tool: agent.toolName,
+					toolDetail: agent.toolDetail,
+				});
+				// Keep log to last 50 entries
+				if (state.activityLog.length > 50) {
+					state.activityLog = state.activityLog.slice(-50);
+				}
+			}
+		}
+	}
+}
+
+let lastRendered = "";
+
+function render(state: SidebarState): void {
+	const output = state.wizard ? renderWizard(state.wizard, state.cols) : renderSidebar(state);
+	if (output === lastRendered) return;
+	lastRendered = output;
+	process.stdout.write(output);
+}
+
+async function handleWizardInput(
+	state: SidebarState,
+	data: Buffer,
+	config: { editor: string },
+): Promise<void> {
+	const wizard = state.wizard;
+	if (!wizard) return;
+
+	const key = parseKeyWizard(data);
+
+	switch (wizard.step) {
+		case "select-repo": {
+			const filtered = wizard.repos.filter((r) =>
+				r.name.toLowerCase().includes(wizard.filter.toLowerCase()),
+			);
+			switch (key.type) {
+				case "up":
+					wizard.selectedIndex = Math.max(0, wizard.selectedIndex - 1);
+					break;
+				case "down":
+					wizard.selectedIndex = Math.min(filtered.length - 1, wizard.selectedIndex + 1);
+					break;
+				case "enter": {
+					const selected = filtered[wizard.selectedIndex];
+					if (selected) {
+						state.wizard = {
+							step: "select-mode",
+							repo: selected,
+							selectedIndex: 0,
+							repos: wizard.repos,
+						};
+					}
+					break;
+				}
+				case "escape":
+					state.wizard = null;
+					break;
+				case "backspace":
+					wizard.filter = wizard.filter.slice(0, -1);
+					wizard.selectedIndex = 0;
+					break;
+				case "char":
+					wizard.filter += key.char;
+					wizard.selectedIndex = 0;
+					break;
+			}
+			break;
+		}
+		case "select-mode": {
+			switch (key.type) {
+				case "up":
+					wizard.selectedIndex = Math.max(0, wizard.selectedIndex - 1);
+					break;
+				case "down":
+					wizard.selectedIndex = Math.min(2, wizard.selectedIndex + 1);
+					break;
+				case "enter":
+					if (wizard.selectedIndex === 0) {
+						// Create new worktree (git wt)
+						state.wizard = {
+							step: "enter-branch",
+							repo: wizard.repo,
+							branchName: "",
+							repos: wizard.repos,
+						};
+					} else if (wizard.selectedIndex === 1) {
+						// Use existing worktree
+						const worktrees = await listWorktrees(wizard.repo.path);
+						state.wizard = {
+							step: "select-worktree",
+							repo: wizard.repo,
+							worktrees: worktrees,
+							selectedIndex: 0,
+							repos: wizard.repos,
+						};
+					} else if (wizard.selectedIndex === 2) {
+						// Open repository root
+						await createSessionFromPath(
+							wizard.repo,
+							wizard.repo.path,
+							wizard.repo.defaultBranch,
+							config.editor,
+						);
+						state.wizard = null;
+						refreshSessions(state);
+					}
+					break;
+				case "escape":
+					state.wizard = {
+						step: "select-repo",
+						repos: wizard.repos,
+						selectedIndex: 0,
+						filter: "",
+					};
+					break;
+			}
+			break;
+		}
+		case "select-worktree": {
+			switch (key.type) {
+				case "up":
+					wizard.selectedIndex = Math.max(0, wizard.selectedIndex - 1);
+					break;
+				case "down":
+					wizard.selectedIndex = Math.min(wizard.worktrees.length - 1, wizard.selectedIndex + 1);
+					break;
+				case "enter": {
+					const selected = wizard.worktrees[wizard.selectedIndex];
+					if (selected) {
+						await createSessionFromPath(wizard.repo, selected.path, selected.branch, config.editor);
+						state.wizard = null;
+						refreshSessions(state);
+					}
+					break;
+				}
+				case "escape":
+					state.wizard = {
+						step: "select-mode",
+						repo: wizard.repo,
+						selectedIndex: 1,
+						repos: wizard.repos,
+					};
+					break;
+			}
+			break;
+		}
+		case "enter-branch": {
+			switch (key.type) {
+				case "enter": {
+					if (wizard.branchName.trim()) {
+						await createSession(wizard.repo, wizard.branchName.trim(), config.editor);
+						state.wizard = null;
+						refreshSessions(state);
+					}
+					break;
+				}
+				case "escape":
+					state.wizard = {
+						step: "select-mode",
+						repo: wizard.repo,
+						selectedIndex: 0,
+						repos: wizard.repos,
+					};
+					break;
+				case "backspace":
+					wizard.branchName = wizard.branchName.slice(0, -1);
+					break;
+				case "char":
+					wizard.branchName += key.char;
+					break;
+			}
+			break;
+		}
+	}
+}
+
+async function createSessionFromPath(
+	repo: RepoInfo,
+	worktreePath: string,
+	branch: string,
+	editor: string,
+): Promise<void> {
+	try {
+		const sessionName = sessionNameFromBranch(branch);
+		const session = {
+			id: randomUUID().slice(0, 8),
+			sessionName: `${repo.name}:${sessionName}`,
+			worktreePath,
+			branch,
+			repoName: repo.name,
+			agents: [],
+			editorState: "open" as const,
+			createdAt: Date.now(),
+			lastActiveAt: Date.now(),
+		};
+		saveSession(session);
+		await openEditor(worktreePath, editor);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : "Unknown error";
+		process.stderr.write(`\nError creating session: ${msg}\n`);
+	}
+}
+
+async function createSession(repo: RepoInfo, branchName: string, editor: string): Promise<void> {
+	try {
+		const worktreePath = await createWorktree(repo.path, branchName);
+		await createSessionFromPath(repo, worktreePath, branchName, editor);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : "Unknown error";
+		process.stderr.write(`\nError creating session: ${msg}\n`);
+	}
+}
+
+async function handleDeleteConfirmInput(state: SidebarState, data: Buffer): Promise<void> {
+	const confirm = state.deleteConfirm;
+	if (!confirm) return;
+
+	const key = parseKeyWizard(data);
+
+	switch (key.type) {
+		case "up":
+			confirm.selectedIndex = Math.max(0, confirm.selectedIndex - 1);
+			break;
+		case "down":
+			confirm.selectedIndex = Math.min(1, confirm.selectedIndex + 1);
+			break;
+		case "enter": {
+			// Close the VS Code window for this session
+			const basename = confirm.worktreePath.split("/").pop() ?? "";
+			await closeEditorWindow(basename);
+
+			// Delete session state
+			deleteSession(confirm.sessionId);
+
+			if (confirm.selectedIndex === 1) {
+				// Also remove worktree
+				try {
+					await removeWorktree(confirm.worktreePath);
+				} catch {
+					// Worktree might already be removed or busy
+				}
+			}
+
+			state.deleteConfirm = null;
+			refreshSessions(state);
+			break;
+		}
+		case "escape":
+			state.deleteConfirm = null;
+			break;
+	}
+}
+
+export async function runSidebar(): Promise<void> {
+	const config = loadConfig();
+	const state = createInitialState();
+
+	// Initial load
+	await refreshSessions(state);
+	cleanStaleAgents();
+
+	// Enable raw mode for keyboard input
+	enableRawMode();
+	process.stdout.write(CURSOR_HIDE);
+
+	// Handle terminal resize — also reposition VS Code windows
+	process.stdout.on("resize", async () => {
+		state.rows = process.stdout.rows ?? 24;
+		state.cols = process.stdout.columns ?? 80;
+		render(state);
+		// Reposition all VS Code windows to fill remaining space
+		await repositionAllEditors();
+	});
+
+	// Animation timer (200ms) — only repaint when there's something animating
+	const animTimer = setInterval(() => {
+		state.animationFrame++;
+		const hasAnimated = state.sessions.some(
+			(s) =>
+				s.editorState === "launching" ||
+				s.agents.some((a) => a.status === "running" || a.status === "waiting"),
+		);
+		if (hasAnimated || state.wizard || state.deleteConfirm || state.quitConfirm) {
+			render(state);
+		}
+	}, 200);
+
+	// Refresh timer (2s) - reload state files, agent states, editor states
+	const refreshTimer = setInterval(async () => {
+		cleanStaleAgents();
+		await refreshSessions(state);
+		render(state);
+	}, 2000);
+
+	// Initial render
+	render(state);
+
+	// Handle keyboard input
+	const cleanup = () => {
+		clearInterval(animTimer);
+		clearInterval(refreshTimer);
+		process.stdout.write(CURSOR_SHOW);
+		disableRawMode();
+	};
+
+	process.stdin.on("data", async (data: Buffer) => {
+		// Quit confirmation mode
+		if (state.quitConfirm) {
+			const key = parseKeyWizard(data);
+			switch (key.type) {
+				case "up":
+					state.quitConfirm.selectedIndex = Math.max(0, state.quitConfirm.selectedIndex - 1);
+					break;
+				case "down":
+					state.quitConfirm.selectedIndex = Math.min(1, state.quitConfirm.selectedIndex + 1);
+					break;
+				case "enter":
+					if (state.quitConfirm.selectedIndex === 1) {
+						// Close VS Code windows for all managed sessions
+						for (const session of state.sessions) {
+							const basename = session.worktreePath.split("/").pop() ?? "";
+							await closeEditorWindow(basename);
+						}
+					}
+					cleanup();
+					process.exit(0);
+					break;
+				case "escape":
+					state.quitConfirm = null;
+					break;
+			}
+			render(state);
+			return;
+		}
+
+		// Delete confirmation mode
+		if (state.deleteConfirm) {
+			await handleDeleteConfirmInput(state, data);
+			render(state);
+			return;
+		}
+
+		// Wizard mode
+		if (state.wizard) {
+			await handleWizardInput(state, data, { editor: config.editor });
+			render(state);
+			return;
+		}
+
+		const key = parseKey(data);
+
+		switch (key.type) {
+			case "quit":
+				state.quitConfirm = { selectedIndex: 0 };
+				break;
+
+			case "up":
+				state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+				break;
+
+			case "down":
+				state.selectedIndex = Math.min(state.sessions.length - 1, state.selectedIndex + 1);
+				break;
+
+			case "enter":
+			case "tab": {
+				const session = state.sessions[state.selectedIndex];
+				if (session) {
+					const focused = await focusEditor(session.worktreePath, config.editor);
+					if (!focused) {
+						// Show launching state while VS Code opens
+						session.editorState = "launching";
+						render(state);
+						await openEditor(session.worktreePath, config.editor);
+						session.editorState = "open";
+					}
+				}
+				break;
+			}
+
+			case "new": {
+				const repos = await scanRepos(config.workspace_dirs);
+				state.wizard = {
+					step: "select-repo",
+					repos,
+					selectedIndex: 0,
+					filter: "",
+				};
+				break;
+			}
+
+			case "delete": {
+				const session = state.sessions[state.selectedIndex];
+				if (session) {
+					state.deleteConfirm = {
+						sessionId: session.id,
+						worktreePath: session.worktreePath,
+						selectedIndex: 0,
+					};
+				}
+				break;
+			}
+
+			case "compact":
+				state.compactMode = !state.compactMode;
+				break;
+
+			case "log":
+				state.showActivityLog = !state.showActivityLog;
+				break;
+
+			case "realign":
+				await repositionAllEditors();
+				break;
+
+			case "mouse_click": {
+				const clicked = state.cardRowRanges.find(
+					(r) => key.row >= r.startRow && key.row <= r.endRow,
+				);
+				if (clicked) {
+					state.selectedIndex = clicked.sessionIndex;
+					const session = state.sessions[clicked.sessionIndex];
+					if (session) {
+						const focused = await focusEditor(session.worktreePath, config.editor);
+						if (!focused) {
+							session.editorState = "launching";
+							render(state);
+							await openEditor(session.worktreePath, config.editor);
+							session.editorState = "open";
+						}
+					}
+				}
+				break;
+			}
+		}
+
+		render(state);
+	});
+
+	// Handle process signals
+	process.on("SIGINT", () => {
+		cleanup();
+		process.exit(0);
+	});
+
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+}

package/src/tui/ansi.ts

@@ -0,0 +1,148 @@
+// ANSI escape code utilities for 256-color terminal rendering
+
+export const ESC = "\x1b";
+export const CSI = `${ESC}[`;
+
+// Screen control
+export const CLEAR_SCREEN = `${CSI}2J`;
+export const CURSOR_HOME = `${CSI}H`;
+export const CURSOR_HIDE = `${CSI}?25l`;
+export const CURSOR_SHOW = `${CSI}?25h`;
+// Text attributes
+export const RESET = `${CSI}0m`;
+export const BOLD = `${CSI}1m`;
+export const DIM = `${CSI}2m`;
+
+// Color helpers (256-color)
+export function fg256(code: number): string {
+	return `${CSI}38;5;${code}m`;
+}
+
+export function bg256(code: number): string {
+	return `${CSI}48;5;${code}m`;
+}
+
+// Theme colors
+export const COLORS = {
+	running: fg256(82), // bright green
+	waiting: fg256(220), // yellow/orange
+	idle: fg256(73), // teal
+	error: fg256(196), // red
+	unknown: fg256(245), // gray
+
+	title: fg256(255), // white
+	subtitle: fg256(250), // light gray
+	muted: fg256(240), // dark gray
+	border: fg256(238), // subtle border
+	highlight: fg256(117), // light blue
+	accent: fg256(213), // pink/magenta
+
+	bgSelected: bg256(236), // dark highlight
+	bgHeader: bg256(235), // header background
+
+	// Editor state colors
+	editorFocused: fg256(255), // bright white — focused editor
+	editorOpen: fg256(117), // cyan — open but not focused
+	editorClosed: fg256(240), // dark gray — closed
+	borderFocused: fg256(255), // bright white border
+	borderOpen: fg256(248), // light gray border
+	borderClosed: fg256(235), // very dark border
+} as const;
+
+// Status colors
+export function statusColor(status: string): string {
+	switch (status) {
+		case "running":
+			return COLORS.running;
+		case "waiting":
+			return COLORS.waiting;
+		case "idle":
+			return COLORS.idle;
+		case "error":
+			return COLORS.error;
+		default:
+			return COLORS.unknown;
+	}
+}
+
+// Status icons
+export function statusIcon(status: string, frame: number): string {
+	const pulse = frame % 4 < 2;
+	switch (status) {
+		case "running":
+			return "\u25cf"; // ●
+		case "waiting":
+			return pulse ? "\u25cf" : "\u25cb";
+		case "idle":
+			return "\u25cb"; // ○
+		case "error":
+			return "\u25cf"; // ●
+		default:
+			return "\u25cb";
+	}
+}
+
+// Utility functions
+export function stripAnsi(str: string): string {
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape codes contain control characters
+	return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export function visibleLength(str: string): number {
+	return stripAnsi(str).length;
+}
+
+export function truncate(str: string, maxLen: number): string {
+	const visible = stripAnsi(str);
+	if (visible.length <= maxLen) return str;
+
+	// ANSI-aware truncation: walk through the string preserving escape sequences
+	let visCount = 0;
+	let result = "";
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape codes contain control characters
+	const re = /(\x1b\[[0-9;]*m)|(.)/g;
+	let m = re.exec(str);
+	while (m !== null) {
+		if (m[1]) {
+			// ANSI escape sequence — always include
+			result += m[1];
+		} else if (m[2]) {
+			if (visCount >= maxLen - 1) {
+				result += `${RESET}\u2026`;
+				return result;
+			}
+			result += m[2];
+			visCount++;
+		}
+		m = re.exec(str);
+	}
+	return result;
+}
+
+export function shortenHome(path: string): string {
+	const home = process.env.HOME ?? "";
+	if (home && path.startsWith(home)) {
+		return `~${path.slice(home.length)}`;
+	}
+	return path;
+}
+
+export function moveCursor(row: number, col: number): string {
+	return `${CSI}${row};${col}H`;
+}
+
+export function clearLine(): string {
+	return `${CSI}2K`;
+}
+
+// Box-drawing characters
+export const BOX = {
+	topLeft: "\u256d",
+	topRight: "\u256e",
+	bottomLeft: "\u2570",
+	bottomRight: "\u256f",
+	horizontal: "\u2500",
+	vertical: "\u2502",
+	teeRight: "\u251c",
+	teeLeft: "\u2524",
+} as const;