// Bun 特有的 feature flags 导入
import { feature } from 'bun:bundle'

// 条件性功能启用
if (feature('COORDINATOR_MODE')) {
  // 多代理协调模式
}

// Tool.ts - 核心类型定义
export type Tool<
  Input extends AnyObject = AnyObject,
  Output = unknown,
  P extends ToolProgressData = ToolProgressData,
> = {
  // 基本信息
  name: string
  aliases?: string[]           // 别名支持
  searchHint?: string          // 工具搜索提示

  // Schema 定义
  inputSchema: Input           // Zod 输入验证
  outputSchema?: z.ZodType     // 输出类型

  // 核心方法
  call(
    args: z.infer<Input>,
    context: ToolUseContext,
    canUseTool: CanUseToolFn,
    parentMessage: AssistantMessage,
    onProgress?: ToolCallProgress<P>,
  ): Promise<ToolResult<Output>>

  // 描述生成
  description(input, options): Promise<string>
  prompt(options): Promise<string>

  // 行为判定
  isEnabled(): boolean
  isConcurrencySafe(input): boolean  // 并发安全
  isReadOnly(input): boolean         // 只读操作
  isDestructive?(input): boolean     // 破坏性操作

  // 权限检查
  checkPermissions(input, context): Promise<PermissionResult>
  validateInput?(input, context): Promise<ValidationResult>

  // UI 渲染
  renderToolUseMessage(input, options): React.ReactNode
  renderToolResultMessage?(content, ...): React.ReactNode
  renderToolUseProgressMessage?(...): React.ReactNode

  // 其他
  maxResultSizeChars: number    // 结果大小限制
  userFacingName(input): string // 用户友好名称
  getToolUseSummary?(input): string | null
  getActivityDescription?(input): string | null
}

// Tool.ts - 工具构建工厂
const TOOL_DEFAULTS = {
  isEnabled: () => true,
  isConcurrencySafe: () => false,  // 默认不安全
  isReadOnly: () => false,         // 默认写操作
  isDestructive: () => false,
  checkPermissions: (input) =>
    Promise.resolve({ behavior: 'allow', updatedInput: input }),
  toAutoClassifierInput: () => '',  // 安全分类器
  userFacingName: () => '',
}

export function buildTool<D extends AnyToolDef>(def: D): BuiltTool<D> {
  return {
    ...TOOL_DEFAULTS,
    userFacingName: () => def.name,
    ...def,
  }
}

// tools.ts - 工具注册
export function getAllBaseTools(): Tools {
  return [
    AgentTool,           // 多代理启动
    BashTool,            // Shell 命令执行
    FileReadTool,        // 文件读取
    FileEditTool,        // 文件编辑
    FileWriteTool,       // 文件写入
    GlobTool,            // 文件匹配
    GrepTool,            // 内容搜索
    WebFetchTool,        // 网页获取
    WebSearchTool,       // 网络搜索
    AskUserQuestionTool, // 用户交互
    SkillTool,           // 技能调用
    TaskCreateTool,      // 任务创建
    TaskUpdateTool,      // 任务更新
    // ... 更多工具

    // 条件性工具
    ...(isToolSearchEnabledOptimistic() ? [ToolSearchTool] : []),
    ...(isWorktreeModeEnabled() ? [EnterWorktreeTool, ExitWorktreeTool] : []),
    ...(process.env.USER_TYPE === 'ant' ? [ConfigTool, TungstenTool] : []),
  ]
}

// BashTool.tsx - 输入 Schema
const fullInputSchema = lazySchema(() => z.strictObject({
  command: z.string().describe('The command to execute'),
  timeout: z.number().optional()
    .describe(`Optional timeout in milliseconds (max ${getMaxTimeoutMs()})`),
  description: z.string().optional()
    .describe('Clear, concise description of what this command does'),
  run_in_background: z.boolean().optional()
    .describe('Set to true to run this command in the background'),
  dangerouslyDisableSandbox: z.boolean().optional()
    .describe('Set this to true to dangerously override sandbox mode'),
}))

// 命令分类 - 用于 UI 折叠显示
const BASH_SEARCH_COMMANDS = new Set([
  'find', 'grep', 'rg', 'ag', 'ack', 'locate', 'which', 'whereis'
])

const BASH_READ_COMMANDS = new Set([
  'cat', 'head', 'tail', 'less', 'more', 'wc', 'stat', 'file',
  'jq', 'awk', 'cut', 'sort', 'uniq', 'tr'
])

const BASH_LIST_COMMANDS = new Set(['ls', 'tree', 'du'])

// 检测命令类型
export function isSearchOrReadBashCommand(command: string): {
  isSearch: boolean
  isRead: boolean
  isList: boolean
} {
  // 解析管道和复合命令
  const partsWithOperators = splitCommandWithOperators(command)

  // 分析每个部分的命令类型
  for (const part of partsWithOperators) {
    const baseCommand = part.trim().split(/\s+/)[0]
    if (BASH_SEARCH_COMMANDS.has(baseCommand)) hasSearch = true
    if (BASH_READ_COMMANDS.has(baseCommand)) hasRead = true
    if (BASH_LIST_COMMANDS.has(baseCommand)) hasList = true
  }

  return { isSearch, isRead, isList }
}

// commands.ts
type Command = {
  type: 'prompt' | 'local' | 'dialog'
  name: string
  description: string
  source: 'builtin' | 'skill' | 'plugin' | 'mcp'

  // prompt 类型：生成提示词
  getPromptForCommand?(args, context): Promise<string>

  // local 类型：本地执行
  run?(args, context): Promise<void>

  // dialog 类型：显示对话框
  launch?(context): Promise<void>

  // 其他属性
  contentLength?: number
  progressMessage?: string
  aliases?: string[]
  isEnabled?(): boolean
}

// commands.ts - 命令导入
import commit from './commands/commit.js'
import review from './commands/review.js'
import config from './commands/config/index.js'
import mcp from './commands/mcp/index.js'
import skills from './commands/skills/index.js'
// ... 50+ 命令导入

// 条件性命令（死代码消除）
const agentsPlatform =
  process.env.USER_TYPE === 'ant'
    ? require('./commands/agents-platform/index.js').default
    : null

const proactive =
  feature('PROACTIVE') || feature('KAIROS')
    ? require('./commands/proactive.js').default
    : null

// services/mcp/client.ts
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'

// 自定义错误类
export class McpAuthError extends Error {
  serverName: string
  constructor(serverName: string, message: string) {
    super(message)
    this.name = 'McpAuthError'
    this.serverName = serverName
  }
}

// 会话过期错误
class McpSessionExpiredError extends Error {
  constructor(serverName: string) {
    super(`MCP server "${serverName}" session expired`)
    this.name = 'McpSessionExpiredError'
  }
}

// 工具调用错误（携带 _meta）
export class McpToolCallError extends TelemetrySafeError {
  constructor(
    message: string,
    telemetryMessage: string,
    readonly mcpMeta?: { _meta?: Record<string, unknown> },
  ) { ... }
}

// services/mcp/mcpStringUtils.ts
export function buildMcpToolName(serverName: string, toolName: string): string {
  return `mcp__${normalizeNameForMCP(serverName)}__${normalizeNameForMCP(toolName)}`
}

// 示例：mcp__github__create_issue

// tools/AgentTool/AgentTool.tsx
export const AgentTool = buildTool({
  name: AGENT_TOOL_NAME,
  aliases: [LEGACY_AGENT_TOOL_NAME],
  searchHint: 'delegate work to a subagent',
  maxResultSizeChars: 100_000,

  inputSchema: z.object({
    description: z.string().describe('A short (3-5 word) description'),
    prompt: z.string().describe('The task for the agent to perform'),
    subagent_type: z.string().optional(),
    model: z.enum(['sonnet', 'opus', 'haiku']).optional(),
    run_in_background: z.boolean().optional(),

    // 多代理参数
    name: z.string().optional(),
    team_name: z.string().optional(),
    mode: permissionModeSchema().optional(),

    // 隔离模式
    isolation: z.enum(['worktree', 'remote']).optional(),
    cwd: z.string().optional(),
  }),

  outputSchema: z.union([
    // 同步完成
    z.object({
      status: z.literal('completed'),
      prompt: z.string(),
    }),
    // 异步启动
    z.object({
      status: z.literal('async_launched'),
      agentId: z.string(),
      outputFile: z.string(),
    }),
    // Teammate 启动（内部）
    z.object({
      status: z.literal('teammate_spawned'),
      teammate_id: z.string(),
      tmux_session_name: z.string(),
    }),
  ]),
})

// tools/AgentTool/loadAgentsDir.ts
export type AgentDefinition = {
  name: string
  model?: 'sonnet' | 'opus' | 'haiku'
  description: string
  prompt: string
  tools?: string[]           // 允许的工具列表
  mcpServers?: string[]      // 需要的 MCP 服务器
  aliases?: string[]
  color?: AgentColorName
  isCustom?: boolean
}

// 从 ~/.claude/agents/ 目录加载自定义代理
export function parseAgentsFromJson(content: string): AgentDefinition[] {
  // 解析 JSON 配置文件
}

// ink.ts - Ink 框架封装
import inkRender, { createRoot as inkCreateRoot } from './ink/root.js'

// 主题包装器
function withTheme(node: ReactNode): ReactNode {
  return createElement(ThemeProvider, null, node)
}

// 导出的渲染函数
export async function render(node: ReactNode, options?): Promise<Instance> {
  return inkRender(withTheme(node), options)
}

export async function createRoot(options?): Promise<Root> {
  const root = await inkCreateRoot(options)
  return {
    ...root,
    render: node => root.render(withTheme(node)),
  }
}

// 设计系统组件导出
export { Box } from './components/design-system/ThemedBox.js'
export { Text } from './components/design-system/ThemedText.js'
export { ThemeProvider, useTheme } from './components/design-system/ThemeProvider.js'

// 工具消息渲染
renderToolUseMessage(input, options): React.ReactNode {
  const theme = useTheme()
  return (
    <Box>
      <Text color={theme.primary}>
        {userFacingName(input)}
      </Text>
      <Text color={theme.secondary}>
        {getToolUseSummary(input)}
      </Text>
    </Box>
  )
}

// state/AppStateStore.ts
export type AppState = {
  // 基础状态
  verbose: boolean
  mainLoopModel: string
  thinkingConfig: ThinkingConfig

  // 工具与命令
  tools: Tools
  commands: Command[]
  mcp: {
    clients: MCPServerConnection[]
    tools: Tools
    resources: Record<string, ServerResource[]>
  }

  // 权限
  toolPermissionContext: ToolPermissionContext

  // 消息
  messages: Message[]

  // 任务
  tasks: Map<string, TaskState>
  backgroundAgents: Map<AgentId, BackgroundAgentState>

  // UI 状态
  promptSuggestion: PromptSuggestionState
  fileHistory: FileHistoryState

  // 特殊模式
  planMode?: PlanModeState
  speculation?: SpeculationState
}

// Store 实现（类似 Redux）
export type AppStateStore = {
  getState(): AppState
  setState(updater: (prev: AppState) => AppState): void
  subscribe(listener: (state: AppState) => void): () => void
}

// state/AppState.tsx
export const AppStoreContext = React.createContext<AppStateStore | null>(null)

export function AppStateProvider({ children, initialState }) {
  const [store] = useState(() => createStore(initialState))

  // 监听设置变化
  useSettingsChange(source => applySettingsChange(source, store.setState))

  return (
    <AppStoreContext.Provider value={store}>
      <MailboxProvider>
        <VoiceProvider>
          {children}
        </VoiceProvider>
      </MailboxProvider>
    </AppStoreContext.Provider>
  )
}

// 选择器 Hook（类似 useSelector）
export function useAppState<T>(selector: (state: AppState) => T): T {
  const store = useContext(AppStoreContext)
  return useSyncExternalStore(
    store.subscribe,
    () => selector(store.getState()),
  )
}

// skills/bundled/index.ts
export function initBundledSkills(): void {
  registerUpdateConfigSkill()    // /update-config
  registerKeybindingsSkill()     // 快捷键
  registerVerifySkill()          // 验证
  registerDebugSkill()           // 调试
  registerRememberSkill()        // 记忆
  registerSimplifySkill()        // 简化
  registerBatchSkill()           // 批处理
  registerStuckSkill()           // 问题诊断

  // 条件性技能
  if (feature('KAIROS')) {
    require('./dream.js').registerDreamSkill()
  }
  if (feature('AGENT_TRIGGERS')) {
    require('./loop.js').registerLoopSkill()
  }
}

// skills/loadSkillsDir.ts
export function registerBundledSkill(skill: {
  name: string
  description: string
  type: 'prompt' | 'local'
  getPromptForCommand?(args, context): Promise<string>
  run?(args, context): Promise<void>
  isEnabled?(): boolean
}): void {
  // 注册到命令系统
}

// plugins/bundled/index.ts
export function initBuiltinPlugins(): void {
  // 内置插件注册（用户可启用/禁用）
}

// 插件加载
// utils/plugins/pluginLoader.ts
export async function loadAllPlugins(): Promise<Plugin[]> {
  // 从 ~/.claude/plugins/ 加载
}

// main.tsx - 启动入口
import { profileCheckpoint } from './utils/startupProfiler.js'
import { startMdmRawRead } from './utils/settings/mdm/rawRead.js'
import { startKeychainPrefetch } from './utils/secureStorage/keychainPrefetch.js'

// 1. 入口标记
profileCheckpoint('main_tsx_entry')

// 2. 并行启动 MDM 配置读取
startMdmRawRead()  // ~135ms 的异步操作

// 3. 并行启动 Keychain 预取
startKeychainPrefetch()  // macOS OAuth + API Key

// 4. 继续其他导入...

// 条件性导入模式
/* eslint-disable @typescript-eslint/no-require-imports */
const REPLTool =
  process.env.USER_TYPE === 'ant'
    ? require('./tools/REPLTool/REPLTool.js').REPLTool
    : null

const proactive =
  feature('PROACTIVE') || feature('KAIROS')
    ? require('./commands/proactive.js').default
    : null
/* eslint-enable @typescript-eslint/no-require-imports */

// 在工具注册时过滤
export function getAllBaseTools(): Tools {
  return [
    // ... 基础工具
    ...(process.env.USER_TYPE === 'ant' && REPLTool ? [REPLTool] : []),
    ...(feature('COORDINATOR_MODE') ? [coordinatorTools] : []),
  ]
}

// settings.json 权限规则示例
{
  "toolPermissions": {
    "allow": [
      "Bash(git *)",       // Git 命令允许
      "Read(**)",          // 所有读取允许
      "Edit(src/**)"       // src 目录编辑允许
    ],
    "deny": [
      "Bash(rm -rf /*)",   // 危险命令拒绝
      "Bash(npm publish)"  // 发布命令拒绝
    ],
    "ask": [
      "Bash(*)"            // 其他 Bash 需询问
    ]
  }
}

// utils/sandbox/sandbox-adapter.ts
export class SandboxManager {
  // 命令在沙箱中执行
  // - 文件系统隔离
  // - 网络限制
  // - 进程限制
}

// buildTool() 工厂函数
export function buildTool<D extends AnyToolDef>(def: D): BuiltTool<D> {
  return { ...TOOL_DEFAULTS, ...def }
}

// 工具的权限检查策略
checkPermissions(input, context): Promise<PermissionResult> {
  // 不同工具有不同的检查策略
}

// AppState Store 的订阅机制
export type AppStateStore = {
  subscribe(listener: (state: AppState) => void): () => void
}

// Command 系统封装操作
type Command = {
  type: 'prompt' | 'local' | 'dialog'
  run?(args, context): Promise<void>
}

// MCP 工具作为外部工具的代理
export class MCPTool implements Tool {
  // 代理 MCP server 的工具调用
}

// withTheme 包装器
function withTheme(node: ReactNode): ReactNode {
  return createElement(ThemeProvider, null, node)
}

// lazySchema 延迟 Schema 定义
const inputSchema = lazySchema(() => z.object({...}))