@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/tmux-subagent/session-created-event.ts

@@ -1,44 +0,0 @@
-type UnknownRecord = Record<string, unknown>
-
-function isRecord(value: unknown): value is UnknownRecord {
-  return typeof value === "object" && value !== null
-}
-
-function getNestedRecord(value: unknown, key: string): UnknownRecord | undefined {
-  if (!isRecord(value)) return undefined
-  const nested = value[key]
-  return isRecord(nested) ? nested : undefined
-}
-
-function getNestedString(value: unknown, key: string): string | undefined {
-  if (!isRecord(value)) return undefined
-  const nested = value[key]
-  return typeof nested === "string" ? nested : undefined
-}
-
-export interface SessionCreatedEvent {
-  type: string
-  properties?: { info?: { id?: string; parentID?: string; title?: string } }
-}
-
-export function coerceSessionCreatedEvent(input: {
-  type: string
-  properties?: unknown
-}): SessionCreatedEvent {
-  const properties = isRecord(input.properties) ? input.properties : undefined
-  const info = getNestedRecord(properties, "info")
-
-  return {
-    type: input.type,
-    properties:
-      info || properties
-        ? {
-            info: {
-              id: getNestedString(info, "id"),
-              parentID: getNestedString(info, "parentID"),
-              title: getNestedString(info, "title"),
-            },
-          }
-        : undefined,
-  }
-}

package/src/features/tmux-subagent/session-created-handler.ts

@@ -1,175 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { TmuxConfig } from "../../config/schema"
-import type { CapacityConfig, TrackedSession } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideSpawnActions, type SessionMapping } from "./decision-engine"
-import { executeActions } from "./action-executor"
-import type { SessionCreatedEvent } from "./session-created-event"
-import { createTrackedSession } from "./tracked-session-state"
-
-type OpencodeClient = PluginInput["client"]
-
-export interface SessionCreatedHandlerDeps {
-  client: OpencodeClient
-  tmuxConfig: TmuxConfig
-  serverUrl: string
-  sourcePaneId: string | undefined
-  sessions: Map<string, TrackedSession>
-  pendingSessions: Set<string>
-  isInsideTmux: () => boolean
-  isEnabled: () => boolean
-  getCapacityConfig: () => CapacityConfig
-  getSessionMappings: () => SessionMapping[]
-  waitForSessionReady: (sessionId: string) => Promise<boolean>
-  startPolling: () => void
-}
-
-export async function handleSessionCreated(
-  deps: SessionCreatedHandlerDeps,
-  event: SessionCreatedEvent,
-): Promise<void> {
-  const enabled = deps.isEnabled()
-  log("[tmux-session-manager] onSessionCreated called", {
-    enabled,
-    tmuxConfigEnabled: deps.tmuxConfig.enabled,
-    isInsideTmux: deps.isInsideTmux(),
-    eventType: event.type,
-    infoId: event.properties?.info?.id,
-    infoParentID: event.properties?.info?.parentID,
-  })
-
-  if (!enabled) return
-  if (event.type !== "session.created") return
-
-  const info = event.properties?.info
-  if (!info?.id || !info?.parentID) return
-
-  const sessionId = info.id
-  const title = info.title ?? "Subagent"
-
-  if (deps.sessions.has(sessionId) || deps.pendingSessions.has(sessionId)) {
-    log("[tmux-session-manager] session already tracked or pending", { sessionId })
-    return
-  }
-
-  if (!deps.sourcePaneId) {
-    log("[tmux-session-manager] no source pane id")
-    return
-  }
-
-  deps.pendingSessions.add(sessionId)
-
-  try {
-    const state = await queryWindowState(deps.sourcePaneId)
-    if (!state) {
-      log("[tmux-session-manager] failed to query window state")
-      return
-    }
-
-    log("[tmux-session-manager] window state queried", {
-      windowWidth: state.windowWidth,
-      mainPane: state.mainPane?.paneId,
-      agentPaneCount: state.agentPanes.length,
-      agentPanes: state.agentPanes.map((p) => p.paneId),
-    })
-
-    const decision = decideSpawnActions(
-      state,
-      sessionId,
-      title,
-      deps.getCapacityConfig(),
-      deps.getSessionMappings(),
-    )
-
-    log("[tmux-session-manager] spawn decision", {
-      canSpawn: decision.canSpawn,
-      reason: decision.reason,
-      actionCount: decision.actions.length,
-      actions: decision.actions.map((a) => {
-        if (a.type === "close") return { type: "close", paneId: a.paneId }
-        if (a.type === "replace") {
-          return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId }
-        }
-        return { type: "spawn", sessionId: a.sessionId }
-      }),
-    })
-
-    if (!decision.canSpawn) {
-      log("[tmux-session-manager] cannot spawn", { reason: decision.reason })
-      return
-    }
-
-    const result = await executeActions(decision.actions, {
-      config: deps.tmuxConfig,
-      serverUrl: deps.serverUrl,
-      windowState: state,
-    })
-
-    for (const { action, result: actionResult } of result.results) {
-      if (action.type === "close" && actionResult.success) {
-        deps.sessions.delete(action.sessionId)
-        log("[tmux-session-manager] removed closed session from cache", {
-          sessionId: action.sessionId,
-        })
-      }
-      if (action.type === "replace" && actionResult.success) {
-        deps.sessions.delete(action.oldSessionId)
-        log("[tmux-session-manager] removed replaced session from cache", {
-          oldSessionId: action.oldSessionId,
-          newSessionId: action.newSessionId,
-        })
-      }
-    }
-
-    if (!result.success || !result.spawnedPaneId) {
-      log("[tmux-session-manager] spawn failed", {
-        success: result.success,
-        results: result.results.map((r) => ({
-          type: r.action.type,
-          success: r.result.success,
-          error: r.result.error,
-        })),
-      })
-      return
-    }
-
-    const sessionReady = await deps.waitForSessionReady(sessionId)
-    if (!sessionReady) {
-      log("[tmux-session-manager] session not ready after timeout, closing spawned pane", {
-        sessionId,
-        paneId: result.spawnedPaneId,
-      })
-
-      await executeActions(
-        [{ type: "close", paneId: result.spawnedPaneId, sessionId }],
-        {
-          config: deps.tmuxConfig,
-          serverUrl: deps.serverUrl,
-          windowState: state,
-        },
-      )
-
-      return
-    }
-
-    deps.sessions.set(
-      sessionId,
-      createTrackedSession({
-        sessionId,
-        paneId: result.spawnedPaneId,
-        description: title,
-      }),
-    )
-
-    log("[tmux-session-manager] pane spawned and tracked", {
-      sessionId,
-      paneId: result.spawnedPaneId,
-      sessionReady,
-    })
-
-    deps.startPolling()
-  } finally {
-    deps.pendingSessions.delete(sessionId)
-  }
-}

package/src/features/tmux-subagent/session-deleted-handler.ts

@@ -1,50 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideCloseAction, type SessionMapping } from "./decision-engine"
-import { executeAction } from "./action-executor"
-
-export interface SessionDeletedHandlerDeps {
-  tmuxConfig: TmuxConfig
-  serverUrl: string
-  sourcePaneId: string | undefined
-  sessions: Map<string, TrackedSession>
-  isEnabled: () => boolean
-  getSessionMappings: () => SessionMapping[]
-  stopPolling: () => void
-}
-
-export async function handleSessionDeleted(
-  deps: SessionDeletedHandlerDeps,
-  event: { sessionID: string },
-): Promise<void> {
-  if (!deps.isEnabled()) return
-  if (!deps.sourcePaneId) return
-
-  const tracked = deps.sessions.get(event.sessionID)
-  if (!tracked) return
-
-  log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
-
-  const state = await queryWindowState(deps.sourcePaneId)
-  if (!state) {
-    deps.sessions.delete(event.sessionID)
-    return
-  }
-
-  const closeAction = decideCloseAction(state, event.sessionID, deps.getSessionMappings())
-  if (closeAction) {
-    await executeAction(closeAction, {
-      config: deps.tmuxConfig,
-      serverUrl: deps.serverUrl,
-      windowState: state,
-    })
-  }
-
-  deps.sessions.delete(event.sessionID)
-
-  if (deps.sessions.size === 0) {
-    deps.stopPolling()
-  }
-}

package/src/features/tmux-subagent/session-message-count.ts

@@ -1,3 +0,0 @@
-export function getMessageCount(data: unknown): number {
-  return Array.isArray(data) ? data.length : 0
-}

package/src/features/tmux-subagent/session-ready-waiter.ts

@@ -1,44 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  SESSION_READY_POLL_INTERVAL_MS,
-  SESSION_READY_TIMEOUT_MS,
-} from "../../shared/tmux"
-import { log } from "../../shared"
-import { parseSessionStatusMap } from "./session-status-parser"
-
-type OpencodeClient = PluginInput["client"]
-
-export async function waitForSessionReady(params: {
-  client: OpencodeClient
-  sessionId: string
-}): Promise<boolean> {
-  const startTime = Date.now()
-
-  while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
-    try {
-      const statusResult = await params.client.session.status({ path: undefined })
-      const allStatuses = parseSessionStatusMap(statusResult.data)
-
-      if (allStatuses[params.sessionId]) {
-        log("[tmux-session-manager] session ready", {
-          sessionId: params.sessionId,
-          status: allStatuses[params.sessionId].type,
-          waitedMs: Date.now() - startTime,
-        })
-        return true
-      }
-    } catch (error) {
-      log("[tmux-session-manager] session status check error", { error: String(error) })
-    }
-
-    await new Promise<void>((resolve) => {
-      setTimeout(resolve, SESSION_READY_POLL_INTERVAL_MS)
-    })
-  }
-
-  log("[tmux-session-manager] session ready timeout", {
-    sessionId: params.sessionId,
-    timeoutMs: SESSION_READY_TIMEOUT_MS,
-  })
-  return false
-}

package/src/features/tmux-subagent/session-status-parser.ts

@@ -1,17 +0,0 @@
-type SessionStatus = { type: string }
-
-export function parseSessionStatusMap(data: unknown): Record<string, SessionStatus> {
-  if (typeof data !== "object" || data === null) return {}
-  const record = data as Record<string, unknown>
-
-  const result: Record<string, SessionStatus> = {}
-  for (const [sessionId, value] of Object.entries(record)) {
-    if (typeof value !== "object" || value === null) continue
-    const valueRecord = value as Record<string, unknown>
-    const type = valueRecord["type"]
-    if (typeof type !== "string") continue
-    result[sessionId] = { type }
-  }
-
-  return result
-}

package/src/features/tmux-subagent/spawn-action-decider.ts

@@ -1,147 +0,0 @@
-import type {
-	CapacityConfig,
-	PaneAction,
-	SpawnDecision,
-	TmuxPaneInfo,
-	WindowState,
-} from "./types"
-import { computeAgentAreaWidth } from "./tmux-grid-constants"
-import {
-	canSplitPane,
-	findMinimalEvictions,
-	isSplittableAtCount,
-} from "./pane-split-availability"
-import { findSpawnTarget } from "./spawn-target-finder"
-import { findOldestAgentPane, type SessionMapping } from "./oldest-agent-pane"
-
-function getInitialSplitDirection(layout?: string): "-h" | "-v" {
-	return layout === "main-horizontal" ? "-v" : "-h"
-}
-
-function isStrictMainLayout(layout?: string): boolean {
-	return layout === "main-vertical" || layout === "main-horizontal"
-}
-
-export function decideSpawnActions(
-	state: WindowState,
-	sessionId: string,
-	description: string,
-	config: CapacityConfig,
-	sessionMappings: SessionMapping[],
-): SpawnDecision {
-	if (!state.mainPane) {
-		return { canSpawn: false, actions: [], reason: "no main pane found" }
-	}
-
-	const agentAreaWidth = computeAgentAreaWidth(state.windowWidth, config)
-	const minAgentPaneWidth = config.agentPaneWidth
-	const currentCount = state.agentPanes.length
-	const strictLayout = isStrictMainLayout(config.layout)
-	const initialSplitDirection = getInitialSplitDirection(config.layout)
-
-	if (agentAreaWidth < minAgentPaneWidth && currentCount > 0) {
-		return {
-			canSpawn: false,
-			actions: [],
-			reason: `window too small for agent panes: ${state.windowWidth}x${state.windowHeight}`,
-		}
-	}
-
-	const oldestPane = findOldestAgentPane(state.agentPanes, sessionMappings)
-	const oldestMapping = oldestPane
-		? sessionMappings.find((m) => m.paneId === oldestPane.paneId) ?? null
-		: null
-
-	if (currentCount === 0) {
-		const virtualMainPane: TmuxPaneInfo = { ...state.mainPane, width: state.windowWidth }
-		if (canSplitPane(virtualMainPane, initialSplitDirection, minAgentPaneWidth)) {
-			return {
-				canSpawn: true,
-				actions: [
-					{
-						type: "spawn",
-						sessionId,
-						description,
-						targetPaneId: state.mainPane.paneId,
-						splitDirection: initialSplitDirection,
-					},
-				],
-			}
-		}
-		return { canSpawn: false, actions: [], reason: "mainPane too small to split" }
-	}
-
-	const canEvaluateSpawnTarget =
-		strictLayout ||
-		isSplittableAtCount(agentAreaWidth, currentCount, minAgentPaneWidth)
-
-	if (canEvaluateSpawnTarget) {
-		const spawnTarget = findSpawnTarget(state, config)
-		if (spawnTarget) {
-			return {
-				canSpawn: true,
-				actions: [
-					{
-						type: "spawn",
-						sessionId,
-						description,
-						targetPaneId: spawnTarget.targetPaneId,
-						splitDirection: spawnTarget.splitDirection,
-					},
-				],
-			}
-		}
-	}
-
-	if (!strictLayout) {
-		const minEvictions = findMinimalEvictions(
-			agentAreaWidth,
-			currentCount,
-			minAgentPaneWidth,
-		)
-		if (minEvictions === 1 && oldestPane) {
-			return {
-				canSpawn: true,
-				actions: [
-					{
-						type: "close",
-						paneId: oldestPane.paneId,
-						sessionId: oldestMapping?.sessionId || "",
-					},
-					{
-						type: "spawn",
-						sessionId,
-						description,
-						targetPaneId: state.mainPane.paneId,
-						splitDirection: initialSplitDirection,
-					},
-				],
-				reason: "closed 1 pane to make room for split",
-			}
-		}
-	}
-
-	if (oldestPane) {
-		return {
-			canSpawn: false,
-			actions: [],
-			reason: "no split target available (defer attach)",
-		}
-	}
-
-	return { canSpawn: false, actions: [], reason: "no split target available (defer attach)" }
-}
-
-export function decideCloseAction(
-	state: WindowState,
-	sessionId: string,
-	sessionMappings: SessionMapping[],
-): PaneAction | null {
-	const mapping = sessionMappings.find((m) => m.sessionId === sessionId)
-	if (!mapping) return null
-
-	const paneExists = state.agentPanes.some((pane) => pane.paneId === mapping.paneId)
-	if (!paneExists) return null
-
-	return { type: "close", paneId: mapping.paneId, sessionId }
-}

package/src/features/tmux-subagent/spawn-target-finder.ts

@@ -1,146 +0,0 @@
-import type { CapacityConfig, SplitDirection, TmuxPaneInfo, WindowState } from "./types"
-import { computeMainPaneWidth } from "./tmux-grid-constants"
-import { computeGridPlan, mapPaneToSlot } from "./grid-planning"
-import { canSplitPane } from "./pane-split-availability"
-
-export interface SpawnTarget {
-	targetPaneId: string
-	splitDirection: SplitDirection
-}
-
-function isStrictMainVertical(config: CapacityConfig): boolean {
-	return config.layout === "main-vertical"
-}
-
-function isStrictMainHorizontal(config: CapacityConfig): boolean {
-	return config.layout === "main-horizontal"
-}
-
-function isStrictMainLayout(config: CapacityConfig): boolean {
-	return isStrictMainVertical(config) || isStrictMainHorizontal(config)
-}
-
-function getInitialSplitDirection(config: CapacityConfig): SplitDirection {
-	return isStrictMainHorizontal(config) ? "-v" : "-h"
-}
-
-function getStrictFollowupSplitDirection(config: CapacityConfig): SplitDirection {
-	return isStrictMainHorizontal(config) ? "-h" : "-v"
-}
-
-function sortPanesForStrictLayout(panes: TmuxPaneInfo[], config: CapacityConfig): TmuxPaneInfo[] {
-	if (isStrictMainHorizontal(config)) {
-		return [...panes].sort((a, b) => a.left - b.left || a.top - b.top)
-	}
-	return [...panes].sort((a, b) => a.top - b.top || a.left - b.left)
-}
-
-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,
-	config: CapacityConfig,
-	_preferredDirection?: SplitDirection,
-): SpawnTarget | null {
-	if (!state.mainPane) return null
-	const existingCount = state.agentPanes.length
-	const minAgentPaneWidth = config.agentPaneWidth
-	const initialDirection = getInitialSplitDirection(config)
-
-	if (existingCount === 0) {
-		const virtualMainPane: TmuxPaneInfo = { ...state.mainPane, width: state.windowWidth }
-		if (canSplitPane(virtualMainPane, initialDirection, minAgentPaneWidth)) {
-			return { targetPaneId: state.mainPane.paneId, splitDirection: initialDirection }
-		}
-		return null
-	}
-
-	if (isStrictMainLayout(config)) {
-		const followupDirection = getStrictFollowupSplitDirection(config)
-		const panesByPriority = sortPanesForStrictLayout(state.agentPanes, config)
-		for (const pane of panesByPriority) {
-			if (canSplitPane(pane, followupDirection, minAgentPaneWidth)) {
-				return { targetPaneId: pane.paneId, splitDirection: followupDirection }
-			}
-		}
-		return null
-	}
-
-	const plan = computeGridPlan(
-		state.windowWidth,
-		state.windowHeight,
-		existingCount + 1,
-		config,
-	)
-	const mainPaneWidth = computeMainPaneWidth(state.windowWidth, config)
-	const occupancy = buildOccupancy(state.agentPanes, plan, mainPaneWidth)
-	const targetSlot = findFirstEmptySlot(occupancy, plan)
-
-	const leftPane = occupancy.get(`${targetSlot.row}:${targetSlot.col - 1}`)
-	if (
-		!isStrictMainVertical(config) &&
-		leftPane &&
-		canSplitPane(leftPane, "-h", minAgentPaneWidth)
-	) {
-		return { targetPaneId: leftPane.paneId, splitDirection: "-h" }
-	}
-
-	const abovePane = occupancy.get(`${targetSlot.row - 1}:${targetSlot.col}`)
-	if (abovePane && canSplitPane(abovePane, "-v", minAgentPaneWidth)) {
-		return { targetPaneId: abovePane.paneId, splitDirection: "-v" }
-	}
-
-	const panesByPosition = [...state.agentPanes].sort(
-		(a, b) => a.left - b.left || a.top - b.top,
-	)
-
-	for (const pane of panesByPosition) {
-		if (canSplitPane(pane, "-v", minAgentPaneWidth)) {
-			return { targetPaneId: pane.paneId, splitDirection: "-v" }
-		}
-	}
-
-	if (isStrictMainVertical(config)) {
-		return null
-	}
-
-	for (const pane of panesByPosition) {
-		if (canSplitPane(pane, "-h", minAgentPaneWidth)) {
-			return { targetPaneId: pane.paneId, splitDirection: "-h" }
-		}
-	}
-
-	return null
-}
-
-export function findSpawnTarget(
-	state: WindowState,
-	config: CapacityConfig,
-): SpawnTarget | null {
-	return findSplittableTarget(state, config)
-}

package/src/features/tmux-subagent/tmux-grid-constants.ts

@@ -1,57 +0,0 @@
-import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from "./types"
-import type { CapacityConfig } from "./types"
-
-export const MAIN_PANE_RATIO = 0.5
-const DEFAULT_MAIN_PANE_SIZE = MAIN_PANE_RATIO * 100
-export const MAX_COLS = 2
-export const MAX_ROWS = 3
-export const MAX_GRID_SIZE = 4
-export const DIVIDER_SIZE = 1
-
-export const MIN_SPLIT_WIDTH = 2 * MIN_PANE_WIDTH + DIVIDER_SIZE
-export const MIN_SPLIT_HEIGHT = 2 * MIN_PANE_HEIGHT + DIVIDER_SIZE
-
-function clamp(value: number, min: number, max: number): number {
-	return Math.max(min, Math.min(max, value))
-}
-
-export function getMainPaneSizePercent(config?: CapacityConfig): number {
-	return clamp(config?.mainPaneSize ?? DEFAULT_MAIN_PANE_SIZE, 20, 80)
-}
-
-export function computeMainPaneWidth(
-	windowWidth: number,
-	config?: CapacityConfig,
-): number {
-	const safeWindowWidth = Math.max(0, windowWidth)
-	if (!config) {
-		return Math.floor(safeWindowWidth * MAIN_PANE_RATIO)
-	}
-
-	const dividerWidth = DIVIDER_SIZE
-	const minMainPaneWidth = config?.mainPaneMinWidth ?? Math.floor(safeWindowWidth * MAIN_PANE_RATIO)
-	const minAgentPaneWidth = config?.agentPaneWidth ?? MIN_PANE_WIDTH
-	const percentageMainPaneWidth = Math.floor(
-		(safeWindowWidth - dividerWidth) * (getMainPaneSizePercent(config) / 100),
-	)
-	const maxMainPaneWidth = Math.max(0, safeWindowWidth - dividerWidth - minAgentPaneWidth)
-
-	return clamp(
-		Math.max(percentageMainPaneWidth, minMainPaneWidth),
-		0,
-		maxMainPaneWidth,
-	)
-}
-
-export function computeAgentAreaWidth(
-	windowWidth: number,
-	config?: CapacityConfig,
-): number {
-	const safeWindowWidth = Math.max(0, windowWidth)
-	if (!config) {
-		return Math.floor(safeWindowWidth * (1 - MAIN_PANE_RATIO))
-	}
-
-	const mainPaneWidth = computeMainPaneWidth(safeWindowWidth, config)
-	return Math.max(0, safeWindowWidth - DIVIDER_SIZE - mainPaneWidth)
-}