@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/task-toast-manager/manager.ts

@@ -1,251 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { TrackedTask, TaskStatus, ModelFallbackInfo } from "./types"
-import type { ConcurrencyManager } from "../background-agent/concurrency"
-
-type OpencodeClient = PluginInput["client"]
-
-type ClientWithTui = {
-  tui?: {
-    showToast: (opts: { body: { title: string; message: string; variant: string; duration: number } }) => Promise<unknown>
-  }
-}
-
-export class TaskToastManager {
-  private tasks: Map<string, TrackedTask> = new Map()
-  private client: OpencodeClient
-  private concurrencyManager?: ConcurrencyManager
-
-  constructor(client: OpencodeClient, concurrencyManager?: ConcurrencyManager) {
-    this.client = client
-    this.concurrencyManager = concurrencyManager
-  }
-
-  setConcurrencyManager(manager: ConcurrencyManager): void {
-    this.concurrencyManager = manager
-  }
-
-  addTask(task: {
-    id: string
-    sessionID?: string
-    description: string
-    agent: string
-    isBackground: boolean
-    status?: TaskStatus
-    category?: string
-    skills?: string[]
-    modelInfo?: ModelFallbackInfo
-  }): void {
-    const trackedTask: TrackedTask = {
-      id: task.id,
-      sessionID: task.sessionID,
-      description: task.description,
-      agent: task.agent,
-      status: task.status ?? "running",
-      startedAt: new Date(),
-      isBackground: task.isBackground,
-      category: task.category,
-      skills: task.skills,
-      modelInfo: task.modelInfo,
-    }
-
-    this.tasks.set(task.id, trackedTask)
-    this.showTaskListToast(trackedTask)
-  }
-
-  /**
-   * Update task status
-   */
-  updateTask(id: string, status: TaskStatus): void {
-    const task = this.tasks.get(id)
-    if (task) {
-      task.status = status
-    }
-  }
-
-  /**
-   * Update model info for a task by session ID
-   */
-  updateTaskModelBySession(sessionID: string, modelInfo: ModelFallbackInfo): void {
-    if (!sessionID) return
-    const task = Array.from(this.tasks.values()).find((t) => t.sessionID === sessionID)
-    if (!task) return
-    if (task.modelInfo?.model === modelInfo.model && task.modelInfo?.type === modelInfo.type) return
-    task.modelInfo = modelInfo
-    this.showTaskListToast(task)
-  }
-
-  /**
-   * Remove completed/error task
-   */
-  removeTask(id: string): void {
-    this.tasks.delete(id)
-  }
-
-  /**
-   * Get all running tasks (newest first)
-   */
-  getRunningTasks(): TrackedTask[] {
-    const running = Array.from(this.tasks.values())
-      .filter((t) => t.status === "running")
-      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime())
-    return running
-  }
-
-  /**
-   * Get all queued tasks
-   */
-  getQueuedTasks(): TrackedTask[] {
-    return Array.from(this.tasks.values())
-      .filter((t) => t.status === "queued")
-      .sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime())
-  }
-
-  /**
-   * Format duration since task started
-   */
-  private formatDuration(startedAt: Date): string {
-    const seconds = Math.floor((Date.now() - startedAt.getTime()) / 1000)
-    if (seconds < 60) return `${seconds}s`
-    const minutes = Math.floor(seconds / 60)
-    if (minutes < 60) return `${minutes}m ${seconds % 60}s`
-    const hours = Math.floor(minutes / 60)
-    return `${hours}h ${minutes % 60}m`
-  }
-
-  private getConcurrencyInfo(): string {
-    if (!this.concurrencyManager) return ""
-    const running = this.getRunningTasks()
-    const queued = this.getQueuedTasks()
-    const total = running.length + queued.length
-    const limit = this.concurrencyManager.getConcurrencyLimit("default")
-    if (limit === Infinity) return ""
-    return ` [${total}/${limit}]`
-  }
-
-  private buildTaskListMessage(newTask: TrackedTask): string {
-    const running = this.getRunningTasks()
-    const queued = this.getQueuedTasks()
-    const concurrencyInfo = this.getConcurrencyInfo()
-
-    const formatTaskIdentifier = (task: TrackedTask): string => {
-      const modelName = task.modelInfo?.model?.split("/").pop()
-      if (modelName && task.category) return `${modelName}: ${task.category}`
-      if (modelName) return modelName
-      if (task.category) return `${task.agent}/${task.category}`
-      return task.agent
-    }
-    const lines: string[] = []
-
-    const isFallback = newTask.modelInfo && (
-      newTask.modelInfo.type === "inherited" ||
-      newTask.modelInfo.type === "system-default" ||
-      newTask.modelInfo.type === "runtime-fallback"
-    )
-    if (isFallback) {
-      const suffixMap: Record<"inherited" | "system-default" | "runtime-fallback", string> = {
-        inherited: " (inherited from parent)",
-        "system-default": " (system default fallback)",
-        "runtime-fallback": " (runtime fallback)",
-      }
-      const suffix = suffixMap[newTask.modelInfo!.type as "inherited" | "system-default" | "runtime-fallback"]
-      lines.push(`[FALLBACK] Model: ${newTask.modelInfo!.model}${suffix}`)
-      lines.push("")
-    }
-
-    if (running.length > 0) {
-      lines.push(`Running (${running.length}):${concurrencyInfo}`)
-      for (const task of running) {
-        const duration = this.formatDuration(task.startedAt)
-        const bgIcon = task.isBackground ? "[BG]" : "[RUN]"
-        const isNew = task.id === newTask.id ? " ← NEW" : ""
-        const taskId = formatTaskIdentifier(task)
-        const skillsInfo = task.skills?.length ? ` [${task.skills.join(", ")}]` : ""
-        lines.push(`${bgIcon} ${task.description} (${taskId})${skillsInfo} - ${duration}${isNew}`)
-      }
-    }
-
-    if (queued.length > 0) {
-      if (lines.length > 0) lines.push("")
-      lines.push(`Queued (${queued.length}):`)
-      for (const task of queued) {
-        const bgIcon = task.isBackground ? "[Q]" : "[W]"
-        const taskId = formatTaskIdentifier(task)
-        const skillsInfo = task.skills?.length ? ` [${task.skills.join(", ")}]` : ""
-        const isNew = task.id === newTask.id ? " ← NEW" : ""
-        lines.push(`${bgIcon} ${task.description} (${taskId})${skillsInfo} - Queued${isNew}`)
-      }
-    }
-
-    return lines.join("\n")
-  }
-
-  /**
-   * Show consolidated toast with all running/queued tasks
-   */
-  private showTaskListToast(newTask: TrackedTask): void {
-    const tuiClient = this.client as ClientWithTui
-    if (!tuiClient.tui?.showToast) return
-
-    const message = this.buildTaskListMessage(newTask)
-    const running = this.getRunningTasks()
-    const queued = this.getQueuedTasks()
-
-    const title = newTask.isBackground
-      ? `New Background Task`
-      : `New Task Executed`
-
-    tuiClient.tui.showToast({
-      body: {
-        title,
-        message: message || `${newTask.description} (${newTask.agent})`,
-        variant: "info",
-        duration: running.length + queued.length > 2 ? 5000 : 3000,
-      },
-    }).catch(() => {})
-  }
-
-  /**
-   * Show task completion toast
-   */
-  showCompletionToast(task: { id: string; description: string; duration: string }): void {
-    const tuiClient = this.client as ClientWithTui
-    if (!tuiClient.tui?.showToast) return
-
-    this.removeTask(task.id)
-
-    const remaining = this.getRunningTasks()
-    const queued = this.getQueuedTasks()
-
-    let message = `"${task.description}" finished in ${task.duration}`
-    if (remaining.length > 0 || queued.length > 0) {
-      message += `\n\nStill running: ${remaining.length} | Queued: ${queued.length}`
-    }
-
-    tuiClient.tui.showToast({
-      body: {
-        title: "Task Completed",
-        message,
-        variant: "success",
-        duration: 5000,
-      },
-    }).catch(() => {})
-  }
-}
-
-let instance: TaskToastManager | null = null
-
-export function getTaskToastManager(): TaskToastManager | null {
-  return instance
-}
-
-export function initTaskToastManager(
-  client: OpencodeClient,
-  concurrencyManager?: ConcurrencyManager
-): TaskToastManager {
-  instance = new TaskToastManager(client, concurrencyManager)
-  return instance
-}
-
-export function _resetTaskToastManagerForTesting(): void {
-  instance = null
-}

package/src/features/task-toast-manager/types.ts

@@ -1,29 +0,0 @@
-import type { ModelSource } from "../../shared/model-resolver"
-
-export type TaskStatus = "running" | "queued" | "completed" | "error"
-
-export interface ModelFallbackInfo {
-  model: string
-  type: "user-defined" | "inherited" | "category-default" | "system-default" | "runtime-fallback"
-  source?: ModelSource
-}
-
-export interface TrackedTask {
-  id: string
-  sessionID?: string
-  description: string
-  agent: string
-  status: TaskStatus
-  startedAt: Date
-  isBackground: boolean
-  category?: string
-  skills?: string[]
-  modelInfo?: ModelFallbackInfo
-}
-
-export interface TaskToastOptions {
-  title: string
-  message: string
-  variant: "info" | "success" | "warning" | "error"
-  duration?: number
-}

package/src/features/tmux-subagent/action-executor-core.ts

@@ -1,82 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { applyLayout, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane, spawnTmuxPane } from "../../shared/tmux"
-import type { PaneAction, WindowState } from "./types"
-
-export interface ActionResult {
-	success: boolean
-	paneId?: string
-	error?: string
-}
-
-export interface ExecuteContext {
-	config: TmuxConfig
-	serverUrl: string
-	windowState: WindowState
-}
-
-export interface ActionExecutorDeps {
-	spawnTmuxPane: typeof spawnTmuxPane
-	closeTmuxPane: typeof closeTmuxPane
-	replaceTmuxPane: typeof replaceTmuxPane
-	applyLayout: typeof applyLayout
-	enforceMainPaneWidth: typeof enforceMainPaneWidth
-}
-
-async function enforceMainPane(
-	windowState: WindowState,
-	config: TmuxConfig,
-	deps: ActionExecutorDeps,
-): Promise<void> {
-	if (!windowState.mainPane) return
-	await deps.enforceMainPaneWidth(
-		windowState.mainPane.paneId,
-		windowState.windowWidth,
-		config.main_pane_size,
-	)
-}
-
-export async function executeActionWithDeps(
-	action: PaneAction,
-	ctx: ExecuteContext,
-	deps: ActionExecutorDeps,
-): Promise<ActionResult> {
-	if (action.type === "close") {
-		const success = await deps.closeTmuxPane(action.paneId)
-		if (success) {
-			await enforceMainPane(ctx.windowState, ctx.config, deps)
-		}
-		return { success }
-	}
-
-	if (action.type === "replace") {
-		const result = await deps.replaceTmuxPane(
-			action.paneId,
-			action.newSessionId,
-			action.description,
-			ctx.config,
-			ctx.serverUrl,
-		)
-		return {
-			success: result.success,
-			paneId: result.paneId,
-		}
-	}
-
-	const result = await deps.spawnTmuxPane(
-		action.sessionId,
-		action.description,
-		ctx.config,
-		ctx.serverUrl,
-		action.targetPaneId,
-		action.splitDirection,
-	)
-
-	if (result.success) {
-		await enforceMainPane(ctx.windowState, ctx.config, deps)
-	}
-
-	return {
-		success: result.success,
-		paneId: result.paneId,
-	}
-}

package/src/features/tmux-subagent/action-executor.ts

@@ -1,137 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { PaneAction, WindowState } from "./types"
-import {
-  applyLayout,
-  spawnTmuxPane,
-  closeTmuxPane,
-  enforceMainPaneWidth,
-  replaceTmuxPane,
-} from "../../shared/tmux"
-import { getTmuxPath } from "../../tools/interactive-bash/tmux-path-resolver"
-import { queryWindowState } from "./pane-state-querier"
-import { log } from "../../shared"
-import type {
-  ActionResult,
-  ActionExecutorDeps,
-} from "./action-executor-core"
-
-export type { ActionExecutorDeps, ActionResult } from "./action-executor-core"
-
-export interface ExecuteActionsResult {
-  success: boolean
-  spawnedPaneId?: string
-  results: Array<{ action: PaneAction; result: ActionResult }>
-}
-
-export interface ExecuteContext {
-  config: TmuxConfig
-  serverUrl: string
-  windowState: WindowState
-  sourcePaneId?: string
-}
-
-async function enforceMainPane(
-  windowState: WindowState,
-  config: TmuxConfig,
-): Promise<void> {
-  if (!windowState.mainPane) return
-  await enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth, {
-    mainPaneSize: config.main_pane_size,
-    mainPaneMinWidth: config.main_pane_min_width,
-    agentPaneMinWidth: config.agent_pane_min_width,
-  })
-}
-
-async function enforceLayoutAndMainPane(ctx: ExecuteContext): Promise<void> {
-  const sourcePaneId = ctx.sourcePaneId
-  if (!sourcePaneId) {
-    await enforceMainPane(ctx.windowState, ctx.config)
-    return
-  }
-
-  const latestState = await queryWindowState(sourcePaneId)
-  if (!latestState?.mainPane) {
-    await enforceMainPane(ctx.windowState, ctx.config)
-    return
-  }
-
-  const tmux = await getTmuxPath()
-  if (tmux) {
-    await applyLayout(tmux, ctx.config.layout, ctx.config.main_pane_size)
-  }
-
-  await enforceMainPane(latestState, ctx.config)
-}
-
-export async function executeAction(
-  action: PaneAction,
-  ctx: ExecuteContext
-): Promise<ActionResult> {
-  if (action.type === "close") {
-    const success = await closeTmuxPane(action.paneId)
-    if (success) {
-      await enforceLayoutAndMainPane(ctx)
-    }
-    return { success }
-  }
-
-  if (action.type === "replace") {
-    const result = await replaceTmuxPane(
-      action.paneId,
-      action.newSessionId,
-      action.description,
-      ctx.config,
-      ctx.serverUrl
-    )
-    if (result.success) {
-      await enforceLayoutAndMainPane(ctx)
-    }
-    return {
-      success: result.success,
-      paneId: result.paneId,
-    }
-  }
-
-  const result = await spawnTmuxPane(
-    action.sessionId,
-    action.description,
-    ctx.config,
-    ctx.serverUrl,
-    action.targetPaneId,
-    action.splitDirection
-  )
-
-  if (result.success) {
-    await enforceLayoutAndMainPane(ctx)
-  }
-
-  return {
-    success: result.success,
-    paneId: result.paneId,
-  }
-}
-
-export async function executeActions(
-  actions: PaneAction[],
-  ctx: ExecuteContext
-): Promise<ExecuteActionsResult> {
-  const results: Array<{ action: PaneAction; result: ActionResult }> = []
-  let spawnedPaneId: string | undefined
-
-  for (const action of actions) {
-    log("[action-executor] executing", { type: action.type })
-    const result = await executeAction(action, ctx)
-    results.push({ action, result })
-
-    if (!result.success) {
-      log("[action-executor] action failed", { type: action.type, error: result.error })
-      return { success: false, results }
-    }
-
-    if ((action.type === "spawn" || action.type === "replace") && result.paneId) {
-      spawnedPaneId = result.paneId
-    }
-  }
-
-  return { success: true, spawnedPaneId, results }
-}

package/src/features/tmux-subagent/cleanup.ts

@@ -1,42 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import { log } from "../../shared"
-import type { TrackedSession } from "./types"
-import { queryWindowState } from "./pane-state-querier"
-import { executeAction } from "./action-executor"
-
-export async function cleanupTmuxSessions(params: {
-  tmuxConfig: TmuxConfig
-  serverUrl: string
-  sourcePaneId: string | undefined
-  sessions: Map<string, TrackedSession>
-  stopPolling: () => void
-}): Promise<void> {
-  params.stopPolling()
-
-  if (params.sessions.size === 0) {
-    log("[tmux-session-manager] cleanup complete")
-    return
-  }
-
-  log("[tmux-session-manager] closing all panes", { count: params.sessions.size })
-  const state = params.sourcePaneId ? await queryWindowState(params.sourcePaneId) : null
-
-  if (state) {
-    const closePromises = Array.from(params.sessions.values()).map((tracked) =>
-      executeAction(
-        { type: "close", paneId: tracked.paneId, sessionId: tracked.sessionId },
-        { config: params.tmuxConfig, serverUrl: params.serverUrl, windowState: state },
-      ).catch((error) =>
-        log("[tmux-session-manager] cleanup error for pane", {
-          paneId: tracked.paneId,
-          error: String(error),
-        }),
-      ),
-    )
-
-    await Promise.all(closePromises)
-  }
-
-  params.sessions.clear()
-  log("[tmux-session-manager] cleanup complete")
-}

package/src/features/tmux-subagent/decision-engine.ts

@@ -1,22 +0,0 @@
-export type { SessionMapping } from "./oldest-agent-pane"
-export type { GridCapacity, GridPlan, GridSlot } from "./grid-planning"
-export type { SpawnTarget } from "./spawn-target-finder"
-
-export {
-	calculateCapacity,
-	computeGridPlan,
-	mapPaneToSlot,
-} from "./grid-planning"
-
-export {
-	canSplitPane,
-	canSplitPaneAnyDirection,
-	findMinimalEvictions,
-	getBestSplitDirection,
-	getColumnCount,
-	getColumnWidth,
-	isSplittableAtCount,
-} from "./pane-split-availability"
-
-export { findSpawnTarget } from "./spawn-target-finder"
-export { decideCloseAction, decideSpawnActions } from "./spawn-action-decider"

package/src/features/tmux-subagent/event-handlers.ts

@@ -1,6 +0,0 @@
-export { coerceSessionCreatedEvent } from "./session-created-event"
-export type { SessionCreatedEvent } from "./session-created-event"
-export { handleSessionCreated } from "./session-created-handler"
-export type { SessionCreatedHandlerDeps } from "./session-created-handler"
-export { handleSessionDeleted } from "./session-deleted-handler"
-export type { SessionDeletedHandlerDeps } from "./session-deleted-handler"

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

@@ -1,137 +0,0 @@
-import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from "./types"
-import type { CapacityConfig, TmuxPaneInfo } from "./types"
-import {
-	DIVIDER_SIZE,
-	MAX_GRID_SIZE,
-	computeAgentAreaWidth,
-} from "./tmux-grid-constants"
-
-export interface GridCapacity {
-	cols: number
-	rows: number
-	total: number
-}
-
-export interface GridSlot {
-	row: number
-	col: number
-}
-
-export interface GridPlan {
-	cols: number
-	rows: number
-	slotWidth: number
-	slotHeight: number
-}
-
-type CapacityOptions = CapacityConfig | number | undefined
-
-function resolveMinPaneWidth(options?: CapacityOptions): number {
-	if (typeof options === "number") {
-		return Math.max(1, options)
-	}
-	if (options && typeof options.agentPaneWidth === "number") {
-		return Math.max(1, options.agentPaneWidth)
-	}
-	return MIN_PANE_WIDTH
-}
-
-function resolveAgentAreaWidth(windowWidth: number, options?: CapacityOptions): number {
-	if (typeof options === "number") {
-		return computeAgentAreaWidth(windowWidth)
-	}
-	return computeAgentAreaWidth(windowWidth, options)
-}
-
-export function calculateCapacity(
-	windowWidth: number,
-	windowHeight: number,
-	options?: CapacityOptions,
-	mainPaneWidth?: number,
-): GridCapacity {
-	const availableWidth =
-		typeof mainPaneWidth === "number"
-			? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE)
-			: resolveAgentAreaWidth(windowWidth, options)
-	const minPaneWidth = resolveMinPaneWidth(options)
-	const cols = Math.min(
-		MAX_GRID_SIZE,
-		Math.max(
-			0,
-			Math.floor(
-				(availableWidth + DIVIDER_SIZE) / (minPaneWidth + DIVIDER_SIZE),
-			),
-		),
-	)
-	const rows = Math.min(
-		MAX_GRID_SIZE,
-		Math.max(
-			0,
-			Math.floor(
-				(windowHeight + DIVIDER_SIZE) / (MIN_PANE_HEIGHT + DIVIDER_SIZE),
-			),
-		),
-	)
-	return { cols, rows, total: cols * rows }
-}
-
-export function computeGridPlan(
-	windowWidth: number,
-	windowHeight: number,
-	paneCount: number,
-	options?: CapacityOptions,
-	mainPaneWidth?: number,
-): GridPlan {
-	const capacity = calculateCapacity(windowWidth, windowHeight, options, mainPaneWidth)
-	const { cols: maxCols, rows: maxRows } = capacity
-
-	if (maxCols === 0 || maxRows === 0 || paneCount === 0) {
-		return { cols: 1, rows: 1, slotWidth: 0, slotHeight: 0 }
-	}
-
-	let bestCols = 1
-	let bestRows = 1
-	let bestArea = Infinity
-
-	for (let rows = 1; rows <= maxRows; rows++) {
-		for (let cols = 1; cols <= maxCols; cols++) {
-			if (cols * rows < paneCount) continue
-			const area = cols * rows
-			if (area < bestArea || (area === bestArea && rows < bestRows)) {
-				bestCols = cols
-				bestRows = rows
-				bestArea = area
-			}
-		}
-	}
-
-	const availableWidth =
-		typeof mainPaneWidth === "number"
-			? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE)
-			: resolveAgentAreaWidth(windowWidth, options)
-	const slotWidth = Math.floor(availableWidth / bestCols)
-	const slotHeight = Math.floor(windowHeight / bestRows)
-
-	return { cols: bestCols, rows: bestRows, slotWidth, slotHeight }
-}
-
-export function mapPaneToSlot(
-	pane: TmuxPaneInfo,
-	plan: GridPlan,
-	mainPaneWidth: number,
-): GridSlot {
-	const rightAreaX = mainPaneWidth
-	const relativeX = Math.max(0, pane.left - rightAreaX)
-	const relativeY = pane.top
-
-	const col =
-		plan.slotWidth > 0
-			? Math.min(plan.cols - 1, Math.floor(relativeX / plan.slotWidth))
-			: 0
-	const row =
-		plan.slotHeight > 0
-			? Math.min(plan.rows - 1, Math.floor(relativeY / plan.slotHeight))
-			: 0
-
-	return { row, col }
-}