oh-my-opencode/src/features/tmux-subagent/spawn-target-finder.ts

import type { SplitDirection, TmuxPaneInfo, WindowState } from "./types"
import { computeGridPlan, mapPaneToSlot } from "./grid-planning"
import { canSplitPane, getBestSplitDirection } from "./pane-split-availability"
import { MIN_PANE_WIDTH } from "./types"

export interface SpawnTarget {
	targetPaneId: string
	splitDirection: SplitDirection
}

function buildOccupancy(
	agentPanes: TmuxPaneInfo[],
	plan: ReturnType<typeof computeGridPlan>,
	mainPaneWidth: number,
): Map<string, TmuxPaneInfo> {
	const occupancy = new Map<string, TmuxPaneInfo>()
	for (const pane of agentPanes) {
		const slot = mapPaneToSlot(pane, plan, mainPaneWidth)
		occupancy.set(`${slot.row}:${slot.col}`, pane)
	}
	return occupancy
}

function findFirstEmptySlot(
	occupancy: Map<string, TmuxPaneInfo>,
	plan: ReturnType<typeof computeGridPlan>,
): { row: number; col: number } {
	for (let row = 0; row < plan.rows; row++) {
		for (let col = 0; col < plan.cols; col++) {
			if (!occupancy.has(`${row}:${col}`)) {
				return { row, col }
			}
		}
	}
	return { row: plan.rows - 1, col: plan.cols - 1 }
}

function findSplittableTarget(
	state: WindowState,
	minPaneWidth: number,
	_preferredDirection?: SplitDirection,
): SpawnTarget | null {
	if (!state.mainPane) return null
	const existingCount = state.agentPanes.length

	if (existingCount === 0) {
		const virtualMainPane: TmuxPaneInfo = { ...state.mainPane, width: state.windowWidth }
		if (canSplitPane(virtualMainPane, "-h", minPaneWidth)) {
			return { targetPaneId: state.mainPane.paneId, splitDirection: "-h" }
		}
		return null
	}

	const plan = computeGridPlan(
		state.windowWidth,
		state.windowHeight,
		existingCount + 1,
		state.mainPane.width,
		minPaneWidth,
	)
	const mainPaneWidth = state.mainPane.width
	const occupancy = buildOccupancy(state.agentPanes, plan, mainPaneWidth)
	const targetSlot = findFirstEmptySlot(occupancy, plan)

	const leftPane = occupancy.get(`${targetSlot.row}:${targetSlot.col - 1}`)
	if (leftPane && canSplitPane(leftPane, "-h", minPaneWidth)) {
		return { targetPaneId: leftPane.paneId, splitDirection: "-h" }
	}

	const abovePane = occupancy.get(`${targetSlot.row - 1}:${targetSlot.col}`)
	if (abovePane && canSplitPane(abovePane, "-v", minPaneWidth)) {
		return { targetPaneId: abovePane.paneId, splitDirection: "-v" }
	}

	const splittablePanes = state.agentPanes
		.map((pane) => ({ pane, direction: getBestSplitDirection(pane, minPaneWidth) }))
		.filter(
			(item): item is { pane: TmuxPaneInfo; direction: SplitDirection } =>
				item.direction !== null,
		)
		.sort((a, b) => b.pane.width * b.pane.height - a.pane.width * a.pane.height)

	const best = splittablePanes[0]
	if (best) {
		return { targetPaneId: best.pane.paneId, splitDirection: best.direction }
	}

	return null
}

export function findSpawnTarget(
	state: WindowState,
	minPaneWidth: number = MIN_PANE_WIDTH,
): SpawnTarget | null {
	return findSplittableTarget(state, minPaneWidth)
}