// src/features/builtin-commands/start-work.ts
export async function startWorkCommand(
  args: { ticket?: string; branch?: string; plan?: string },
  ctx: ToolContext,
): Promise<CommandResult> {
  const steps: WorkStep[] = []

  // === 阶段 1: 工作树创建 ===
  if (args.branch) {
    // 创建 git worktree 支持并行开发
    await ctx.run(`git worktree add work/${args.branch}`)
    ctx.directory = path.join(ctx.directory, 'work', args.branch)
    steps.push({ phase: 'worktree', status: 'completed' })
  }

  // === 阶段 2: Boulder 状态初始化 ===
  // Sisyphus 的" boulder" = 当前任务的状态
  await ctx.run(`mkdir -p .opencode/boulder`)
  await writeFile('.opencode/boulder/state.json', {
    ticket: args.ticket,
    branch: args.branch,
    steps: [],
    startedAt: Date.now(),
  })
  steps.push({ phase: 'boulder', status: 'completed' })

  // === 阶段 3: 任务分解 ===
  const tasks = await ctx.invokeAgent('prometheus', {
    prompt: `Break down this work into granular sub-steps:\n${args.plan ?? 'Implement the requested feature'}`,
  })

  // 写入 Todo 列表
  for (const task of parseTasks(tasks)) {
    await ctx.createTodo(task)
  }
  steps.push({ phase: 'breakdown', status: 'completed', count: tasks.length })

  // === 阶段 4: 上下文加载 ===
  const contextFiles = discoverContextFiles(ctx.directory)
  for (const file of contextFiles) {
    await ctx.injectContext(file)
  }
  steps.push({ phase: 'context', status: 'completed' })

  // === 阶段 5: 启动 Sisyphus ===
  await ctx.invokeAgent('sisyphus', {
    prompt: `Start working on: ${args.plan ?? args.ticket}`,
    continueFrom: 'boulder',
  })

  return {
    summary: `Started work on ${args.ticket ?? 'task'} with ${tasks.length} sub-tasks`,
    steps,
    worktree: args.branch ? `work/${args.branch}` : undefined,
  }
}

// src/features/builtin-commands/refactor.ts
export async function refactorCommand(
  args: { target: string; pattern?: string },
  ctx: ToolContext,
): Promise<CommandResult> {
  const phases: RefactorPhase[] = []

  // === 阶段 1: 并行探索 ===
  // 启动多个 Explore Agent 并行分析
  const explorations = await Promise.all([
    ctx.invokeAgent('explore', { prompt: `Analyze ${args.target} structure` }),
    ctx.invokeAgent('explore', { prompt: `Find callers of ${args.target}` }),
    ctx.invokeAgent('explore', { prompt: `Find tests for ${args.target}` }),
  ])
  phases.push({ name: 'exploration', agents: 3, completed: true })

  // === 阶段 2: 构建代码地图 ===
  const codemap = await ctx.runTool('ast_grep_search', {
    pattern: '$FUNC()',
    language: detectLanguage(args.target),
  })
  phases.push({ name: 'codemap', files: codemap.length, completed: true })

  // === 阶段 3: 测试覆盖评估 ===
  const coverage = await ctx.runTool('lsp_diagnostics', {
    file: args.target,
  })
  phases.push({ name: 'coverage', hasTests: coverage.testFiles > 0, completed: true })

  // === 阶段 4: 计划 Agent 审查 ===
  const plan = await ctx.invokeAgent('momus', {
    prompt: `Review refactoring plan for ${args.target}. ` +
      `Check: files exist, line numbers valid, tests cover the refactored areas.`,
  })

  if (plan.hasBlockingIssues) {
    return { result: 'blocked', issues: plan.issues }
  }
  phases.push({ name: 'review', result: 'approved', completed: true })

  // === 阶段 5: 分步实现 ===
  for (const step of plan.steps) {
    await ctx.invokeAgent('hephaestus', {
      prompt: `Refactoring step: ${step.description}\n` +
        `Focus on: ${step.focus}\n` +
        `Pattern: ${args.pattern}`,
    })

    // LSP 验证
    const diagnostics = await ctx.runTool('lsp_diagnostics', { file: args.target })
    if (diagnostics.errors > 0) {
      phases.push({ name: 'verify', result: 'failed', error: 'LSP errors' })
      break
    }
  }
  phases.push({ name: 'implementation', steps: plan.steps.length, completed: true })

  // === 阶段 6: 最终验证 ===
  const finalCheck = await ctx.runTool('lsp_diagnostics', { file: args.target })
  phases.push({ name: 'final', errors: finalCheck.errors, completed: true })

  return { phases, result: 'success' }
}