@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/ast-grep/types.ts

@@ -1,60 +0,0 @@
-import type { CLI_LANGUAGES } from "./constants"
-
-export type CliLanguage = (typeof CLI_LANGUAGES)[number]
-
-export interface Position {
-  line: number
-  column: number
-}
-
-export interface Range {
-  start: Position
-  end: Position
-}
-
-export interface CliMatch {
-  text: string
-  range: {
-    byteOffset: { start: number; end: number }
-    start: Position
-    end: Position
-  }
-  file: string
-  lines: string
-  charCount: { leading: number; trailing: number }
-  language: string
-}
-
-export interface SearchMatch {
-  file: string
-  text: string
-  range: Range
-  lines: string
-}
-
-export interface MetaVariable {
-  name: string
-  text: string
-  kind: string
-}
-
-export interface AnalyzeResult {
-  text: string
-  range: Range
-  kind: string
-  metaVariables: MetaVariable[]
-}
-
-export interface TransformResult {
-  original: string
-  transformed: string
-  editCount: number
-}
-
-export interface SgResult {
-  matches: CliMatch[]
-  totalMatches: number
-  truncated: boolean
-  truncatedReason?: "max_matches" | "max_output_bytes" | "timeout"
-  error?: string
-}

package/src/tools/background-task/AGENTS.md

@@ -1,53 +0,0 @@
-# src/tools/background-task/ — Background Task Tool Wrappers
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-18 files. Tool-layer wrappers for `background_output` and `background_cancel`. Does NOT implement the background execution engine — that lives in `src/features/background-agent/`. This directory provides the LLM-facing tool interface.
-
-## THREE TOOLS
-
-| Tool | Factory | Purpose |
-|------|---------|---------|
-| `background_output` | `createBackgroundOutput` | Get results from a running/completed background task |
-| `background_cancel` | `createBackgroundCancel` | Cancel running task(s) |
-| `createBackgroundTask` | internal | Shared factory used by both |
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `create-background-output.ts` | `background_output` tool: fetch task results by task_id |
-| `create-background-cancel.ts` | `background_cancel` tool: cancel by taskId or all=true |
-| `create-background-task.ts` | Shared tool factory with common params |
-| `clients.ts` | Client interfaces for background output and cancel |
-| `session-messages.ts` | Fetch session messages from OpenCode |
-| `full-session-format.ts` | Format full session output (messages, thinking blocks) |
-| `task-result-format.ts` | Format task result for LLM consumption |
-| `task-status-format.ts` | Format task status (running/completed/error) |
-| `message-dir.ts` | Temp directory for message exchange |
-| `truncate-text.ts` | Truncate large output to fit context |
-| `time-format.ts` | Human-readable duration formatting |
-| `delay.ts` | Polling delay utility |
-| `types.ts` | `BackgroundTaskOptions`, result/status types |
-| `constants.ts` | Timeout defaults, polling intervals |
-
-## BACKGROUND OUTPUT MODES
-
-```
-background_output(task_id, block=false)  → check current status/result
-background_output(task_id, block=true)   → wait until complete (timeout default: 120s)
-background_output(task_id, full_session=true) → return full session transcript
-background_output(task_id, message_limit=N) → last N messages only
-background_output(task_id, include_thinking=true) → include thinking blocks
-```
-
-## RELATIONSHIP TO BACKGROUND ENGINE
-
-```
-tools/background-task/  ← LLM tool interface
-features/background-agent/  ← execution engine (BackgroundManager)
-```
-
-`createBackgroundOutput` queries `BackgroundManager.getTask(task_id)` — it does not manage task state.

package/src/tools/background-task/clients.ts

@@ -1,32 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-
-export type BackgroundOutputMessage = {
-  id?: string
-  info?: { role?: string; time?: string | { created?: number }; agent?: string }
-  parts?: Array<{
-    type?: string
-    text?: string
-    thinking?: string
-    content?: string | Array<{ type: string; text?: string }>
-    output?: string
-    name?: string
-  }>
-}
-
-export type BackgroundOutputMessagesResult =
-  | { data?: BackgroundOutputMessage[]; error?: unknown }
-  | BackgroundOutputMessage[]
-
-export type BackgroundOutputClient = {
-  session: {
-    messages: (args: { path: { id: string } }) => Promise<BackgroundOutputMessagesResult>
-  }
-}
-
-export type BackgroundCancelClient = {
-  session: {
-    abort: (args: { path: { id: string } }) => Promise<unknown>
-  }
-}
-
-export type BackgroundOutputManager = Pick<BackgroundManager, "getTask">

package/src/tools/background-task/constants.ts

@@ -1,9 +0,0 @@
-export const BACKGROUND_TASK_DESCRIPTION = `Run agent task in background. Returns task_id immediately; notifies on completion.
-
-Use \`background_output\` to get results. Prompts MUST be in English.`
-
-export const BACKGROUND_OUTPUT_DESCRIPTION = `Get output from background task. Use full_session=true to fetch session messages with filters. System notifies on completion, so block=true rarely needed. - Timeout values are in milliseconds (ms), NOT seconds.
-
-IMPORTANT: ONLY call this tool AFTER receiving a <system-reminder> notification for the task. Do NOT call immediately after launching a background task - wait for the notification first.`
-
-export const BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=true to cancel ALL before final answer.`

package/src/tools/background-task/create-background-cancel.ts

@@ -1,115 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { BackgroundCancelArgs } from "./types"
-import type { BackgroundCancelClient } from "./clients"
-import { BACKGROUND_CANCEL_DESCRIPTION } from "./constants"
-
-export function createBackgroundCancel(manager: BackgroundManager, _client: BackgroundCancelClient): ToolDefinition {
-  return tool({
-    description: BACKGROUND_CANCEL_DESCRIPTION,
-    args: {
-      taskId: tool.schema.string().optional().describe("Task ID to cancel (required if all=false)"),
-      all: tool.schema.boolean().optional().describe("Cancel all running background tasks (default: false)"),
-    },
-    async execute(args: BackgroundCancelArgs, toolContext) {
-      try {
-        const cancelAll = args.all === true
-
-        if (!cancelAll && !args.taskId) {
-          return `[ERROR] Invalid arguments: Either provide a taskId or set all=true to cancel all running tasks.`
-        }
-
-        if (cancelAll) {
-          const tasks = manager.getAllDescendantTasks(toolContext.sessionID)
-          const cancellableTasks = tasks.filter((t: { status: string }) => t.status === "running" || t.status === "pending")
-
-          if (cancellableTasks.length === 0) {
-            return `No running or pending background tasks to cancel.`
-          }
-
-          const cancelledInfo: Array<{ id: string; description: string; status: string; sessionID?: string }> = []
-
-          for (const task of cancellableTasks) {
-            const originalStatus = task.status
-            const cancelled = await manager.cancelTask(task.id, {
-              source: "background_cancel",
-              abortSession: originalStatus === "running",
-              skipNotification: true,
-            })
-            if (!cancelled) continue
-            cancelledInfo.push({
-              id: task.id,
-              description: task.description,
-              status: originalStatus === "pending" ? "pending" : "running",
-              sessionID: task.sessionID,
-            })
-          }
-
-          const tableRows = cancelledInfo
-            .map(
-              (t) =>
-                `| \`${t.id}\` | ${t.description} | ${t.status} | ${t.sessionID ? `\`${t.sessionID}\`` : "(not started)"} |`
-            )
-            .join("\n")
-
-          const resumableTasks = cancelledInfo.filter((t) => t.sessionID)
-          const resumeSection =
-            resumableTasks.length > 0
-              ? `\n## Continue Instructions
-
-To continue a cancelled task, use:
-\`\`\`
-task(session_id="<session_id>", prompt="Continue: <your follow-up>")
-\`\`\`
-
-Continuable sessions:
-${resumableTasks.map((t) => `- \`${t.sessionID}\` (${t.description})`).join("\n")}`
-              : ""
-
-          return `Cancelled ${cancelledInfo.length} background task(s):
-
-| Task ID | Description | Status | Session ID |
-|---------|-------------|--------|------------|
-${tableRows}
-${resumeSection}`
-        }
-
-        const task = manager.getTask(args.taskId!)
-        if (!task) {
-          return `[ERROR] Task not found: ${args.taskId}`
-        }
-
-        if (task.status !== "running" && task.status !== "pending") {
-          return `[ERROR] Cannot cancel task: current status is "${task.status}".
-Only running or pending tasks can be cancelled.`
-        }
-
-        const cancelled = await manager.cancelTask(task.id, {
-          source: "background_cancel",
-          abortSession: task.status === "running",
-          skipNotification: true,
-        })
-        if (!cancelled) {
-          return `[ERROR] Failed to cancel task: ${task.id}`
-        }
-
-        if (task.status === "pending") {
-          return `Pending task cancelled successfully
-
-Task ID: ${task.id}
-Description: ${task.description}
-Status: ${task.status}`
-        }
-
-        return `Task cancelled successfully
-
-Task ID: ${task.id}
-Description: ${task.description}
-Session ID: ${task.sessionID}
-Status: ${task.status}`
-      } catch (error) {
-        return `[ERROR] Error cancelling task: ${error instanceof Error ? error.message : String(error)}`
-      }
-    },
-  })
-}

package/src/tools/background-task/create-background-output.ts

@@ -1,159 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin"
-import type { BackgroundTask } from "../../features/background-agent"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import type { BackgroundOutputArgs } from "./types"
-import type { BackgroundOutputClient, BackgroundOutputManager } from "./clients"
-import { BACKGROUND_OUTPUT_DESCRIPTION } from "./constants"
-import { delay } from "./delay"
-import { formatFullSession } from "./full-session-format"
-import { formatTaskResult } from "./task-result-format"
-import { formatTaskStatus } from "./task-status-format"
-
-import { getAgentDisplayName } from "../../shared/agent-display-names"
-import { recordBackgroundOutputConsumption } from "../../shared/background-output-consumption"
-
-const BOB_JUNIOR_AGENT = getAgentDisplayName("sub")
-
-type ToolContextWithMetadata = {
-  sessionID: string
-  messageID?: string
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-  callID?: string
-  callId?: string
-  call_id?: string
-}
-
-function resolveToolCallID(ctx: ToolContextWithMetadata): string | undefined {
-  if (typeof ctx.callID === "string" && ctx.callID.trim() !== "") return ctx.callID
-  if (typeof ctx.callId === "string" && ctx.callId.trim() !== "") return ctx.callId
-  if (typeof ctx.call_id === "string" && ctx.call_id.trim() !== "") return ctx.call_id
-  return undefined
-}
-
-function formatResolvedTitle(task: BackgroundTask): string {
-  const label = task.agent === BOB_JUNIOR_AGENT && task.category ? task.category : task.agent
-  return `${label} - ${task.description}`
-}
-
-function isTaskActiveStatus(status: BackgroundTask["status"]): boolean {
-  return status === "pending" || status === "running"
-}
-
-function appendTimeoutNote(output: string, timeoutMs: number): string {
-  return `${output}\n\n> **Timed out waiting** after ${timeoutMs}ms. Task is still running; showing latest available output.`
-}
-
-export function createBackgroundOutput(manager: BackgroundOutputManager, client: BackgroundOutputClient): ToolDefinition {
-  return tool({
-    description: BACKGROUND_OUTPUT_DESCRIPTION,
-    args: {
-      task_id: tool.schema.string().describe("Task ID to get output from"),
-      block: tool.schema
-        .boolean()
-        .optional()
-        .describe(
-          "Wait for completion (default: false). System notifies when done, so blocking is rarely needed."
-        ),
-      timeout: tool.schema.number().optional().describe("Max wait time in ms (default: 60000, max: 600000)"),
-      full_session: tool.schema.boolean().optional().describe("Return full session messages with filters (default: false)"),
-      include_thinking: tool.schema.boolean().optional().describe("Include thinking/reasoning parts in full_session output (default: false)"),
-      message_limit: tool.schema.number().optional().describe("Max messages to return (capped at 100)"),
-      since_message_id: tool.schema.string().optional().describe("Return messages after this message ID (exclusive)"),
-      include_tool_results: tool.schema.boolean().optional().describe("Include tool results in full_session output (default: false)"),
-      thinking_max_chars: tool.schema.number().optional().describe("Max characters for thinking content (default: 2000)"),
-    },
-    async execute(args: BackgroundOutputArgs, toolContext) {
-      try {
-        const ctx = toolContext as ToolContextWithMetadata
-        const task = manager.getTask(args.task_id)
-        if (!task) {
-          return `Task not found: ${args.task_id}`
-        }
-
-        const meta = {
-          title: formatResolvedTitle(task),
-          metadata: {
-            task_id: task.id,
-            agent: task.agent,
-            category: task.category,
-            description: task.description,
-            ...(task.sessionID ? { sessionId: task.sessionID } : {}),
-          } as Record<string, unknown>,
-        }
-        ctx.metadata?.(meta)
-
-        const callID = resolveToolCallID(ctx)
-        if (callID) {
-          storeToolMetadata(ctx.sessionID, callID, meta)
-        }
-
-        const shouldBlock = args.block === true
-        const timeoutMs = Math.min(args.timeout ?? 60000, 600000)
-
-        let resolvedTask = task
-
-        let didTimeoutWhileActive = false
-
-        if (shouldBlock && isTaskActiveStatus(task.status)) {
-          const startTime = Date.now()
-          while (Date.now() - startTime < timeoutMs) {
-            await delay(1000)
-
-            const currentTask = manager.getTask(args.task_id)
-            if (!currentTask) {
-              return `Task was deleted: ${args.task_id}`
-            }
-
-            resolvedTask = currentTask
-
-            if (!isTaskActiveStatus(currentTask.status)) {
-              break
-            }
-          }
-
-          if (isTaskActiveStatus(resolvedTask.status)) {
-            const finalCheck = manager.getTask(args.task_id)
-            if (finalCheck) {
-              resolvedTask = finalCheck
-            }
-          }
-
-          if (isTaskActiveStatus(resolvedTask.status)) {
-            didTimeoutWhileActive = true
-          }
-        }
-
-        const isActive = isTaskActiveStatus(resolvedTask.status)
-        const fullSession = args.full_session ?? false
-        const includeThinking = isActive || (args.include_thinking ?? false)
-        const includeToolResults = isActive || (args.include_tool_results ?? false)
-
-        if (fullSession) {
-          const output = await formatFullSession(resolvedTask, client, {
-            includeThinking,
-            messageLimit: args.message_limit,
-            sinceMessageId: args.since_message_id,
-            includeToolResults,
-            thinkingMaxChars: args.thinking_max_chars,
-          })
-
-          return didTimeoutWhileActive ? appendTimeoutNote(output, timeoutMs) : output
-        }
-
-        if (resolvedTask.status === "completed") {
-          recordBackgroundOutputConsumption(ctx.sessionID, ctx.messageID, resolvedTask.sessionID)
-          return await formatTaskResult(resolvedTask, client)
-        }
-
-        if (resolvedTask.status === "error" || resolvedTask.status === "cancelled" || resolvedTask.status === "interrupt") {
-          return formatTaskStatus(resolvedTask)
-        }
-
-        const statusOutput = formatTaskStatus(resolvedTask)
-        return didTimeoutWhileActive ? appendTimeoutNote(statusOutput, timeoutMs) : statusOutput
-      } catch (error) {
-        return `Error getting output: ${error instanceof Error ? error.message : String(error)}`
-      }
-    },
-  })
-}

package/src/tools/background-task/create-background-task.ts

@@ -1,126 +0,0 @@
-import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { BackgroundTaskArgs } from "./types"
-import { BACKGROUND_TASK_DESCRIPTION } from "./constants"
-import { resolveMessageContext } from "../../features/hook-message-injector"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { log } from "../../shared/logger"
-import { delay } from "./delay"
-import { getMessageDir } from "./message-dir"
-
-type ToolContextWithMetadata = {
-  sessionID: string
-  messageID: string
-  agent: string
-  abort: AbortSignal
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-  callID?: string
-}
-
-export function createBackgroundTask(
-  manager: BackgroundManager,
-  client: PluginInput["client"]
-): ToolDefinition {
-  return tool({
-    description: BACKGROUND_TASK_DESCRIPTION,
-    args: {
-      description: tool.schema.string().describe("Short task description (shown in status)"),
-      prompt: tool.schema.string().describe("Full detailed prompt for the agent"),
-      agent: tool.schema.string().describe("Agent type to use (registered agent; canonical names preferred)"),
-    },
-    async execute(args: BackgroundTaskArgs, toolContext) {
-      const ctx = toolContext as ToolContextWithMetadata
-
-      if (!args.agent || args.agent.trim() === "") {
-        return `[ERROR] Agent parameter is required. Please specify which agent to use (e.g., "researcher", "strategist", or another registered agent)`
-      }
-
-      try {
-        const messageDir = getMessageDir(ctx.sessionID)
-        const { prevMessage, firstMessageAgent } = await resolveMessageContext(
-          ctx.sessionID,
-          client,
-          messageDir
-        )
-
-        const sessionAgent = getSessionAgent(ctx.sessionID)
-        const parentAgent = ctx.agent ?? sessionAgent ?? firstMessageAgent ?? prevMessage?.agent
-
-        log("[background_task] parentAgent resolution", {
-          sessionID: ctx.sessionID,
-          ctxAgent: ctx.agent,
-          sessionAgent,
-          firstMessageAgent,
-          prevMessageAgent: prevMessage?.agent,
-          resolvedParentAgent: parentAgent,
-        })
-
-        const parentModel =
-          prevMessage?.model?.providerID && prevMessage?.model?.modelID
-            ? {
-                providerID: prevMessage.model.providerID,
-                modelID: prevMessage.model.modelID,
-                ...(prevMessage.model.variant ? { variant: prevMessage.model.variant } : {}),
-              }
-            : undefined
-
-        const task = await manager.launch({
-          description: args.description,
-          prompt: args.prompt,
-          agent: args.agent.trim(),
-          parentSessionID: ctx.sessionID,
-          parentMessageID: ctx.messageID,
-          parentModel,
-          parentAgent,
-        })
-
-        const WAIT_FOR_SESSION_INTERVAL_MS = 50
-        const WAIT_FOR_SESSION_TIMEOUT_MS = 30000
-        const waitStart = Date.now()
-        let sessionId = task.sessionID
-        while (!sessionId && Date.now() - waitStart < WAIT_FOR_SESSION_TIMEOUT_MS) {
-          const updated = manager.getTask(task.id)
-          if (updated?.status === "error" || updated?.status === "cancelled" || updated?.status === "interrupt") {
-            return `Task ${`entered error state`}\.\n\nTask ID: ${task.id}`
-          }
-          sessionId = updated?.sessionID
-          if (sessionId) {
-            break
-          }
-          if (ctx.abort?.aborted) {
-            break
-          }
-          await delay(WAIT_FOR_SESSION_INTERVAL_MS)
-        }
-
-        const bgMeta = {
-          title: args.description,
-          metadata: {
-            ...(sessionId ? { sessionId } : {}),
-          },
-        }
-        ctx.metadata?.(bgMeta)
-
-        if (ctx.callID) {
-          storeToolMetadata(ctx.sessionID, ctx.callID, bgMeta)
-        }
-
-        return `Background task launched successfully.
-
-Task ID: ${task.id}
-Session ID: ${sessionId ?? "(not yet assigned)"}
-Description: ${task.description}
-Agent: ${task.agent}
-Status: ${task.status}
-
-System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.
-
-Do NOT call background_output now. Wait for <system-reminder> notification first.`
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error)
-        return `[ERROR] Failed to launch background task: ${message}`
-      }
-    },
-  })
-}

package/src/tools/background-task/delay.ts

@@ -1,3 +0,0 @@
-export function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}