计划与工作流

// tools/EnterPlanModeTool.ts — 简化版
export class EnterPlanModeTool implements Tool {
  name = 'EnterPlanMode'

  inputSchema = z.object({
    reason: z.string().optional()
      .describe('进入计划模式的原因'),
  })

  description() {
    return '进入计划模式。在此模式下你只能使用只读工具来探索' +
      '代码库，不能修改任何文件。适用于需要先理解代码结构再动手的场景。'
  }

  async call(
    input: { reason?: string },
    context: ToolUseContext
  ): Promise<ToolResult> {
    // 切换全局模式为 Plan
    context.setAppState(state => ({
      ...state,
      permissionMode: 'plan' as PermissionMode,
    }))

    return {
      data: '已进入计划模式。你现在只能使用只读工具（Read, Glob, Grep, LSP 等）。' +
        '请充分探索代码库，制定完整的实施计划后再退出。',
    }
  }

  isReadOnly() { return true }
  isConcurrencySafe() { return true }
}

// tools/ExitPlanModeV2Tool.ts — 简化版
export class ExitPlanModeV2Tool implements Tool {
  name = 'ExitPlanMode'

  inputSchema = z.object({
    plan: z.string().describe('制定的实施计划'),
    allowedPrompts: z.array(z.string()).optional()
      .describe('计划执行的操作清单，展示给用户审查'),
  })

  async call(
    input: { plan: string; allowedPrompts?: string[] },
    context: ToolUseContext
  ): Promise<ToolResult> {
    // 恢复正常模式
    context.setAppState(state => ({
      ...state,
      permissionMode: 'default' as PermissionMode,
    }))

    // 构建计划摘要
    let summary = '计划已制定:\n\n' + input.plan
    if (input.allowedPrompts?.length) {
      summary += '\n\n计划执行的操作:\n'
      summary += input.allowedPrompts
        .map((p, i) => (i + 1) + '. ' + p)
        .join('\n')
    }

    return {
      data: summary,
      // contextModifier 可以将计划注入后续的系统提示词
      contextModifier: (ctx) => ({
        ...ctx,
        activePlan: input.plan,
      }),
    }
  }

  // 只在 Plan 模式下可用
  isEnabled() {
    return getAppState().permissionMode === 'plan'
  }
}

// tools/SkillTool.ts — 简化版
import { readdir, readFile } from 'fs/promises'
import { join } from 'path'

interface SkillDefinition {
  name: string
  description: string
  prompt: string
  source: 'user' | 'bundled'
}

export class SkillTool implements Tool {
  name = 'Skill'

  inputSchema = z.object({
    skill: z.string().describe('要执行的技能名称'),
    args: z.string().optional().describe('传给技能的参数'),
  })

  description() {
    return '执行一个预定义的技能。技能提供特定领域的专业能力。'
  }

  async call(
    input: { skill: string; args?: string },
    context: ToolUseContext
  ): Promise<ToolResult> {
    // 1. 查找技能
    const skill = await this.findSkill(input.skill, context)
    if (!skill) {
      const available = await this.listSkills(context)
      return {
        data: '未找到技能 "' + input.skill + '"。可用技能:\n' +
          available.map(s => '  - ' + s.name + ': ' + s.description).join('\n'),
      }
    }

    // 2. 构建技能提示词
    const skillPrompt = this.buildPrompt(skill, input.args)

    // 3. 延迟加载 queryLoop（避免循环依赖）
    const { runSubConversation } = require('../services/queryLoop')

    // 4. 在子对话中执行技能
    const result = await runSubConversation({
      systemPromptModifier: (basePrompt: string) =>
        basePrompt + '\n\n' + skillPrompt,
      messages: context.messages,
      tools: context.options.tools,
      abortSignal: context.abortController.signal,
    })

    return {
      data: result.output,
      contextModifier: skill.contextModifier,
    }
  }

  private async findSkill(
    name: string,
    context: ToolUseContext
  ): Promise<SkillDefinition | null> {
    // 先搜索用户自定义技能
    const userSkillPath = join(context.options.cwd, '.claude/skills', name)
    try {
      const content = await readFile(userSkillPath + '.md', 'utf-8')
      return { name, prompt: content, description: '', source: 'user' }
    } catch {}

    // 再搜索内置技能
    const bundledSkills = await this.getBundledSkills()
    return bundledSkills.find(s =>
      s.name === name || s.name.includes(name)
    ) ?? null
  }

  private async getBundledSkills(): Promise<SkillDefinition[]> {
    // 17 个内置技能
    return [
      { name: 'batch', description: '批量处理多个文件', prompt: '...', source: 'bundled' },
      { name: 'debug', description: '调试辅助', prompt: '...', source: 'bundled' },
      { name: 'simplify', description: '代码简化', prompt: '...', source: 'bundled' },
      { name: 'verify', description: '验证变更', prompt: '...', source: 'bundled' },
      { name: 'stuck', description: '困境突破', prompt: '...', source: 'bundled' },
      // ... 共 17 个
    ]
  }
}

// tools/ToolSearchTool.ts — 简化版
export class ToolSearchTool implements Tool {
  name = 'ToolSearch'

  inputSchema = z.object({
    query: z.string().describe('搜索关键词'),
  })

  description() {
    return '搜索可用但未加载的工具。' +
      '某些工具（如 NotebookEdit、WebSearch）' +
      '不是默认加载的，需要通过搜索发现。'
  }

  async call(
    input: { query: string },
    context: ToolUseContext
  ): Promise<ToolResult> {
    // 获取所有延迟加载的工具
    const deferredTools = getAllBaseTools().filter(
      t => t.shouldDefer === true
    )

    // 关键词匹配
    const matches = deferredTools.filter(tool => {
      const searchText = [
        tool.name,
        tool.searchHint ?? '',
        tool.description(),
      ].join(' ').toLowerCase()

      return input.query.toLowerCase().split(/\s+/).some(
        keyword => searchText.includes(keyword)
      )
    })

    if (matches.length === 0) {
      return { data: '未找到匹配 "' + input.query + '" 的工具。' }
    }

    // 将找到的工具添加到当前会话
    context.setAppState(state => ({
      ...state,
      additionalTools: [
        ...(state.additionalTools ?? []),
        ...matches,
      ],
    }))

    return {
      data: '找到 ' + matches.length + ' 个工具:\n' +
        matches.map(t =>
          '  - ' + t.name + ': ' + t.description().slice(0, 100)
        ).join('\n') +
        '\n\n这些工具已添加到当前会话，可以直接使用。',
    }
  }
}

// tools/AskUserQuestionTool.ts — 简化版
export class AskUserQuestionTool implements Tool {
  name = 'AskUserQuestion'

  inputSchema = z.object({
    question: z.string().describe('向用户提出的问题'),
    options: z.array(z.string()).optional()
      .describe('选项列表，渲染为按钮'),
    multiSelect: z.boolean().optional()
      .describe('是否允许多选'),
    preview: z.string().optional()
      .describe('预览内容（如 diff）'),
  })

  async call(
    input: {
      question: string
      options?: string[]
      multiSelect?: boolean
      preview?: string
    },
    context: ToolUseContext
  ): Promise<ToolResult> {
    // 等待用户通过 UI 回复
    // 这会暂停 QueryLoop 直到用户输入
    const userResponse = await waitForUserInput({
      prompt: input.question,
      options: input.options,
      multiSelect: input.multiSelect,
      preview: input.preview,
    })

    return {
      data: userResponse.text,
      newMessages: [{
        role: 'user',
        content: userResponse.text,
      }],
    }
  }

  isReadOnly() { return true }
  isConcurrencySafe() { return false }
}