refactor(core): split index.ts and config-handler.ts into focused modules

Main entry point:
- create-hooks.ts, create-tools.ts, create-managers.ts
- plugin-interface.ts: plugin interface types
- plugin/ directory: plugin lifecycle modules

Config handler:
- agent-config-handler.ts, command-config-handler.ts
- tool-config-handler.ts, mcp-config-handler.ts
- provider-config-handler.ts, category-config-resolver.ts
- agent-priority-order.ts, prometheus-agent-config-builder.ts
- plugin-components-loader.ts

src/plugin/hooks/create-tool-guard-hooks.ts

@@ -0,0 +1,98 @@
+import type { HookName, OhMyOpenCodeConfig } from "../../config"
+import type { PluginContext } from "../types"
+
+import {
+  createCommentCheckerHooks,
+  createToolOutputTruncatorHook,
+  createDirectoryAgentsInjectorHook,
+  createDirectoryReadmeInjectorHook,
+  createEmptyTaskResponseDetectorHook,
+  createRulesInjectorHook,
+  createTasksTodowriteDisablerHook,
+  createWriteExistingFileGuardHook,
+} from "../../hooks"
+import {
+  getOpenCodeVersion,
+  isOpenCodeVersionAtLeast,
+  log,
+  OPENCODE_NATIVE_AGENTS_INJECTION_VERSION,
+} from "../../shared"
+import { safeCreateHook } from "../../shared/safe-create-hook"
+
+export type ToolGuardHooks = {
+  commentChecker: ReturnType<typeof createCommentCheckerHooks> | null
+  toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null
+  directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null
+  directoryReadmeInjector: ReturnType<typeof createDirectoryReadmeInjectorHook> | null
+  emptyTaskResponseDetector: ReturnType<typeof createEmptyTaskResponseDetectorHook> | null
+  rulesInjector: ReturnType<typeof createRulesInjectorHook> | null
+  tasksTodowriteDisabler: ReturnType<typeof createTasksTodowriteDisablerHook> | null
+  writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null
+}
+
+export function createToolGuardHooks(args: {
+  ctx: PluginContext
+  pluginConfig: OhMyOpenCodeConfig
+  isHookEnabled: (hookName: HookName) => boolean
+  safeHookEnabled: boolean
+}): ToolGuardHooks {
+  const { ctx, pluginConfig, isHookEnabled, safeHookEnabled } = args
+  const safeHook = <T>(hookName: HookName, factory: () => T): T | null =>
+    safeCreateHook(hookName, factory, { enabled: safeHookEnabled })
+
+  const commentChecker = isHookEnabled("comment-checker")
+    ? safeHook("comment-checker", () => createCommentCheckerHooks(pluginConfig.comment_checker))
+    : null
+
+  const toolOutputTruncator = isHookEnabled("tool-output-truncator")
+    ? safeHook("tool-output-truncator", () =>
+        createToolOutputTruncatorHook(ctx, { experimental: pluginConfig.experimental }))
+    : null
+
+  let directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null = null
+  if (isHookEnabled("directory-agents-injector")) {
+    const currentVersion = getOpenCodeVersion()
+    const hasNativeSupport =
+      currentVersion !== null && isOpenCodeVersionAtLeast(OPENCODE_NATIVE_AGENTS_INJECTION_VERSION)
+    if (hasNativeSupport) {
+      log("directory-agents-injector auto-disabled due to native OpenCode support", {
+        currentVersion,
+        nativeVersion: OPENCODE_NATIVE_AGENTS_INJECTION_VERSION,
+      })
+    } else {
+      directoryAgentsInjector = safeHook("directory-agents-injector", () => createDirectoryAgentsInjectorHook(ctx))
+    }
+  }
+
+  const directoryReadmeInjector = isHookEnabled("directory-readme-injector")
+    ? safeHook("directory-readme-injector", () => createDirectoryReadmeInjectorHook(ctx))
+    : null
+
+  const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector")
+    ? safeHook("empty-task-response-detector", () => createEmptyTaskResponseDetectorHook(ctx))
+    : null
+
+  const rulesInjector = isHookEnabled("rules-injector")
+    ? safeHook("rules-injector", () => createRulesInjectorHook(ctx))
+    : null
+
+  const tasksTodowriteDisabler = isHookEnabled("tasks-todowrite-disabler")
+    ? safeHook("tasks-todowrite-disabler", () =>
+        createTasksTodowriteDisablerHook({ experimental: pluginConfig.experimental }))
+    : null
+
+  const writeExistingFileGuard = isHookEnabled("write-existing-file-guard")
+    ? safeHook("write-existing-file-guard", () => createWriteExistingFileGuardHook(ctx))
+    : null
+
+  return {
+    commentChecker,
+    toolOutputTruncator,
+    directoryAgentsInjector,
+    directoryReadmeInjector,
+    emptyTaskResponseDetector,
+    rulesInjector,
+    tasksTodowriteDisabler,
+    writeExistingFileGuard,
+  }
+}