refactor: wave 2 - split atlas, auto-update-checker, session-recovery, todo-enforcer, background-task hooks

- Extract atlas/ into 15 focused modules (hook, event handler, tool policies, types, etc.) - Split auto-update-checker into checker/ and hook/ subdirectories with single-purpose files - Decompose session-recovery into separate recovery strategy files per error type - Extract todo-continuation-enforcer from monolith to directory with dedicated modules - Split background-task/tools.ts into individual tool creator files - Extract command-executor, tmux-utils into focused sub-modules - Split config/schema.ts into domain-specific schema files - Decompose cli/config-manager.ts into focused modules - Rollback skill-mcp-manager, model-availability, index.ts splits that broke tests - Fix all import path depths for moved files (../../ -> ../../../) - Add explicit type annotations to resolve TS7006 implicit any errors Typecheck: 0 errors Tests: 2359 pass, 5 fail (all pre-existing)
2026-02-08 15:01:42 +09:00
parent 29155ec7bc
commit 119e18c810
158 changed files with 7806 additions and 7050 deletions
@@ -0,0 +1,89 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin"
+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"
+
+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) {
+      try {
+        const task = manager.getTask(args.task_id)
+        if (!task) {
+          return `Task not found: ${args.task_id}`
+        }
+
+        if (args.full_session === true) {
+          return await formatFullSession(task, client, {
+            includeThinking: args.include_thinking === true,
+            messageLimit: args.message_limit,
+            sinceMessageId: args.since_message_id,
+            includeToolResults: args.include_tool_results === true,
+            thinkingMaxChars: args.thinking_max_chars,
+          })
+        }
+
+        const shouldBlock = args.block === true
+        const timeoutMs = Math.min(args.timeout ?? 60000, 600000)
+
+        if (task.status === "completed") {
+          return await formatTaskResult(task, client)
+        }
+
+        if (task.status === "error" || task.status === "cancelled") {
+          return formatTaskStatus(task)
+        }
+
+        if (!shouldBlock) {
+          return formatTaskStatus(task)
+        }
+
+        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}`
+          }
+
+          if (currentTask.status === "completed") {
+            return await formatTaskResult(currentTask, client)
+          }
+
+          if (currentTask.status === "error" || currentTask.status === "cancelled") {
+            return formatTaskStatus(currentTask)
+          }
+        }
+
+        const finalTask = manager.getTask(args.task_id)
+        if (!finalTask) {
+          return `Task was deleted: ${args.task_id}`
+        }
+        return `Timeout exceeded (${timeoutMs}ms). Task still ${finalTask.status}.\n\n${formatTaskStatus(finalTask)}`
+      } catch (error) {
+        return `Error getting output: ${error instanceof Error ? error.message : String(error)}`
+      }
+    },
+  })
+}