justsisyphus
8ebc933118
- Account for tmux pane dividers (1 char) in all size calculations - Reduce MIN_PANE_WIDTH from 53 to 52 to fit 2 columns in standard terminals - Fix enforceMainPaneWidth to use (windowWidth - divider) / 2 - Add virtual mainPane handling for close-spawn eviction loop - Add comprehensive decision-engine tests (23 test cases)
355 lines
9.8 KiB
TypeScript
355 lines
9.8 KiB
TypeScript
import { describe, it, expect } from "bun:test"
|
|
import {
|
|
decideSpawnActions,
|
|
calculateCapacity,
|
|
canSplitPane,
|
|
canSplitPaneAnyDirection,
|
|
getBestSplitDirection,
|
|
type SessionMapping
|
|
} from "./decision-engine"
|
|
import type { WindowState, CapacityConfig, TmuxPaneInfo } from "./types"
|
|
import { MIN_PANE_WIDTH, MIN_PANE_HEIGHT } from "./types"
|
|
|
|
const MIN_SPLIT_WIDTH = 2 * MIN_PANE_WIDTH + 1
|
|
const MIN_SPLIT_HEIGHT = 2 * MIN_PANE_HEIGHT + 1
|
|
|
|
describe("canSplitPane", () => {
|
|
const createPane = (width: number, height: number): TmuxPaneInfo => ({
|
|
paneId: "%1",
|
|
width,
|
|
height,
|
|
left: 100,
|
|
top: 0,
|
|
title: "test",
|
|
isActive: false,
|
|
})
|
|
|
|
it("returns true for horizontal split when width >= 2*MIN+1", () => {
|
|
//#given - pane with exactly minimum splittable width (107)
|
|
const pane = createPane(MIN_SPLIT_WIDTH, 20)
|
|
|
|
//#when
|
|
const result = canSplitPane(pane, "-h")
|
|
|
|
//#then
|
|
expect(result).toBe(true)
|
|
})
|
|
|
|
it("returns false for horizontal split when width < 2*MIN+1", () => {
|
|
//#given - pane just below minimum splittable width
|
|
const pane = createPane(MIN_SPLIT_WIDTH - 1, 20)
|
|
|
|
//#when
|
|
const result = canSplitPane(pane, "-h")
|
|
|
|
//#then
|
|
expect(result).toBe(false)
|
|
})
|
|
|
|
it("returns true for vertical split when height >= 2*MIN+1", () => {
|
|
//#given - pane with exactly minimum splittable height (23)
|
|
const pane = createPane(50, MIN_SPLIT_HEIGHT)
|
|
|
|
//#when
|
|
const result = canSplitPane(pane, "-v")
|
|
|
|
//#then
|
|
expect(result).toBe(true)
|
|
})
|
|
|
|
it("returns false for vertical split when height < 2*MIN+1", () => {
|
|
//#given - pane just below minimum splittable height
|
|
const pane = createPane(50, MIN_SPLIT_HEIGHT - 1)
|
|
|
|
//#when
|
|
const result = canSplitPane(pane, "-v")
|
|
|
|
//#then
|
|
expect(result).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe("canSplitPaneAnyDirection", () => {
|
|
const createPane = (width: number, height: number): TmuxPaneInfo => ({
|
|
paneId: "%1",
|
|
width,
|
|
height,
|
|
left: 100,
|
|
top: 0,
|
|
title: "test",
|
|
isActive: false,
|
|
})
|
|
|
|
it("returns true when can split horizontally but not vertically", () => {
|
|
//#given
|
|
const pane = createPane(MIN_SPLIT_WIDTH, MIN_SPLIT_HEIGHT - 1)
|
|
|
|
//#when
|
|
const result = canSplitPaneAnyDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe(true)
|
|
})
|
|
|
|
it("returns true when can split vertically but not horizontally", () => {
|
|
//#given
|
|
const pane = createPane(MIN_SPLIT_WIDTH - 1, MIN_SPLIT_HEIGHT)
|
|
|
|
//#when
|
|
const result = canSplitPaneAnyDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe(true)
|
|
})
|
|
|
|
it("returns false when cannot split in any direction", () => {
|
|
//#given - pane too small in both dimensions
|
|
const pane = createPane(MIN_SPLIT_WIDTH - 1, MIN_SPLIT_HEIGHT - 1)
|
|
|
|
//#when
|
|
const result = canSplitPaneAnyDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe("getBestSplitDirection", () => {
|
|
const createPane = (width: number, height: number): TmuxPaneInfo => ({
|
|
paneId: "%1",
|
|
width,
|
|
height,
|
|
left: 100,
|
|
top: 0,
|
|
title: "test",
|
|
isActive: false,
|
|
})
|
|
|
|
it("returns -h when only horizontal split possible", () => {
|
|
//#given
|
|
const pane = createPane(MIN_SPLIT_WIDTH, MIN_SPLIT_HEIGHT - 1)
|
|
|
|
//#when
|
|
const result = getBestSplitDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe("-h")
|
|
})
|
|
|
|
it("returns -v when only vertical split possible", () => {
|
|
//#given
|
|
const pane = createPane(MIN_SPLIT_WIDTH - 1, MIN_SPLIT_HEIGHT)
|
|
|
|
//#when
|
|
const result = getBestSplitDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe("-v")
|
|
})
|
|
|
|
it("returns null when no split possible", () => {
|
|
//#given
|
|
const pane = createPane(MIN_SPLIT_WIDTH - 1, MIN_SPLIT_HEIGHT - 1)
|
|
|
|
//#when
|
|
const result = getBestSplitDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe(null)
|
|
})
|
|
|
|
it("returns -h when width >= height and both splits possible", () => {
|
|
//#given - wider than tall
|
|
const pane = createPane(MIN_SPLIT_WIDTH + 10, MIN_SPLIT_HEIGHT)
|
|
|
|
//#when
|
|
const result = getBestSplitDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe("-h")
|
|
})
|
|
|
|
it("returns -v when height > width and both splits possible", () => {
|
|
//#given - taller than wide (height needs to be > width for -v)
|
|
const pane = createPane(MIN_SPLIT_WIDTH, MIN_SPLIT_WIDTH + 10)
|
|
|
|
//#when
|
|
const result = getBestSplitDirection(pane)
|
|
|
|
//#then
|
|
expect(result).toBe("-v")
|
|
})
|
|
})
|
|
|
|
describe("decideSpawnActions", () => {
|
|
const defaultConfig: CapacityConfig = {
|
|
mainPaneMinWidth: 120,
|
|
agentPaneWidth: 40,
|
|
}
|
|
|
|
const createWindowState = (
|
|
windowWidth: number,
|
|
windowHeight: number,
|
|
agentPanes: Array<{ paneId: string; width: number; height: number; left: number; top: number }> = []
|
|
): WindowState => ({
|
|
windowWidth,
|
|
windowHeight,
|
|
mainPane: { paneId: "%0", width: Math.floor(windowWidth / 2), height: windowHeight, left: 0, top: 0, title: "main", isActive: true },
|
|
agentPanes: agentPanes.map((p, i) => ({
|
|
...p,
|
|
title: `agent-${i}`,
|
|
isActive: false,
|
|
})),
|
|
})
|
|
|
|
describe("minimum size enforcement", () => {
|
|
it("returns canSpawn=false when window too small", () => {
|
|
//#given - window smaller than minimum pane size
|
|
const state = createWindowState(50, 5)
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(false)
|
|
expect(result.reason).toContain("too small")
|
|
})
|
|
|
|
it("returns canSpawn=true when main pane can be split", () => {
|
|
//#given - main pane width >= 2*MIN_PANE_WIDTH+1 = 107
|
|
const state = createWindowState(220, 44)
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(true)
|
|
expect(result.actions.length).toBe(1)
|
|
expect(result.actions[0].type).toBe("spawn")
|
|
})
|
|
|
|
it("closes oldest pane when existing panes are too small to split", () => {
|
|
//#given - existing pane is below minimum splittable size
|
|
const state = createWindowState(220, 30, [
|
|
{ paneId: "%1", width: 50, height: 15, left: 110, top: 0 },
|
|
])
|
|
const mappings: SessionMapping[] = [
|
|
{ sessionId: "old-ses", paneId: "%1", createdAt: new Date("2024-01-01") },
|
|
]
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, mappings)
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(true)
|
|
expect(result.actions.length).toBe(2)
|
|
expect(result.actions[0].type).toBe("close")
|
|
expect(result.actions[1].type).toBe("spawn")
|
|
})
|
|
|
|
it("can spawn when existing pane is large enough to split", () => {
|
|
//#given - existing pane is above minimum splittable size
|
|
const state = createWindowState(320, 50, [
|
|
{ paneId: "%1", width: MIN_SPLIT_WIDTH + 10, height: MIN_SPLIT_HEIGHT + 10, left: 160, top: 0 },
|
|
])
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(true)
|
|
expect(result.actions.length).toBe(1)
|
|
expect(result.actions[0].type).toBe("spawn")
|
|
})
|
|
})
|
|
|
|
describe("basic spawn decisions", () => {
|
|
it("returns canSpawn=true when capacity allows new pane", () => {
|
|
//#given - 220x44 window, mainPane width=110 >= MIN_SPLIT_WIDTH(107)
|
|
const state = createWindowState(220, 44)
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(true)
|
|
expect(result.actions.length).toBe(1)
|
|
expect(result.actions[0].type).toBe("spawn")
|
|
})
|
|
|
|
it("spawns with splitDirection", () => {
|
|
//#given
|
|
const state = createWindowState(212, 44, [
|
|
{ paneId: "%1", width: MIN_SPLIT_WIDTH, height: MIN_SPLIT_HEIGHT, left: 106, top: 0 },
|
|
])
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(true)
|
|
expect(result.actions[0].type).toBe("spawn")
|
|
if (result.actions[0].type === "spawn") {
|
|
expect(result.actions[0].sessionId).toBe("ses1")
|
|
expect(result.actions[0].splitDirection).toBeDefined()
|
|
}
|
|
})
|
|
|
|
it("returns canSpawn=false when no main pane", () => {
|
|
//#given
|
|
const state: WindowState = { windowWidth: 212, windowHeight: 44, mainPane: null, agentPanes: [] }
|
|
|
|
//#when
|
|
const result = decideSpawnActions(state, "ses1", "test", defaultConfig, [])
|
|
|
|
//#then
|
|
expect(result.canSpawn).toBe(false)
|
|
expect(result.reason).toBe("no main pane found")
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("calculateCapacity", () => {
|
|
it("calculates 2D grid capacity (cols x rows)", () => {
|
|
//#given - 212x44 window (user's actual screen)
|
|
//#when
|
|
const capacity = calculateCapacity(212, 44)
|
|
|
|
//#then - availableWidth=106, cols=(106+1)/(52+1)=2, rows=(44+1)/(11+1)=3 (accounting for dividers)
|
|
expect(capacity.cols).toBe(2)
|
|
expect(capacity.rows).toBe(3)
|
|
expect(capacity.total).toBe(6)
|
|
})
|
|
|
|
it("returns 0 cols when agent area too narrow", () => {
|
|
//#given - window too narrow for even 1 agent pane
|
|
//#when
|
|
const capacity = calculateCapacity(100, 44)
|
|
|
|
//#then - availableWidth=50, cols=50/53=0
|
|
expect(capacity.cols).toBe(0)
|
|
expect(capacity.total).toBe(0)
|
|
})
|
|
|
|
it("returns 0 rows when window too short", () => {
|
|
//#given - window too short
|
|
//#when
|
|
const capacity = calculateCapacity(212, 10)
|
|
|
|
//#then - rows=10/11=0
|
|
expect(capacity.rows).toBe(0)
|
|
expect(capacity.total).toBe(0)
|
|
})
|
|
|
|
it("scales with larger screens but caps at MAX_GRID_SIZE=4", () => {
|
|
//#given - larger 4K-like screen (400x100)
|
|
//#when
|
|
const capacity = calculateCapacity(400, 100)
|
|
|
|
//#then - cols capped at 4, rows capped at 4 (MAX_GRID_SIZE)
|
|
expect(capacity.cols).toBe(3)
|
|
expect(capacity.rows).toBe(4)
|
|
expect(capacity.total).toBe(12)
|
|
})
|
|
})
|