module RabbotMetaAgent

# File lib/rabbot_meta_agent.rb, line 126
def build_args(prompt:, model:, workspace:, session_id: nil, partial_output: true, trust: true, force: true,
               mode: :plan)
  args = [
    "cursor-agent",
    "--model", model.to_s,
    "--print",
    "--output-format", "stream-json"
  ]
  case mode.to_sym
  when :plan
    args.concat(["--mode", "plan", "--sandbox", "enabled"])
    prompt = plan_prompt(prompt)
  when :agent
    nil
  else
    raise ArgumentError, "unsupported agent mode: #{mode.inspect}"
  end
  args << "--stream-partial-output" if partial_output
  args << "--trust" if trust
  args << "--force" if force
  args << "--workspace" << workspace.to_s
  args << "--resume" << session_id.to_s if session_id && !session_id.to_s.strip.empty?
  args << prompt.to_s
  args
end

# File lib/rabbot_meta_agent.rb, line 219
def execute_stream(args, model:, on_assistant_text:, partial_output:)
  parser = StreamParser.new(
    model: model,
    on_assistant_text: on_assistant_text,
    partial_output: partial_output
  )
  stderr_text = +""

  CursorAgentRunner.popen3(*args, lane: :build) do |stdin, stdout, stderr, wait_thr|
    stdin.close
    stdout.each_line { |line| parser.ingest_line(line) }
    stderr_text = stderr.read
    status = wait_thr.value
    result = parser.to_result(status: status)
    [result, stderr_text]
  end
end

# File lib/rabbot_meta_agent.rb, line 187
def interrupted_result(model:, stderr:)
  message = CursorAgentRunner.failure_message(
    stdout: "",
    stderr: stderr,
    fallback: "Agent exited without a result"
  )
  AgentResult.new(
    success: false,
    text: "",
    duration_ms: 0,
    model: model,
    input_tokens: 0,
    output_tokens: 0,
    error: message,
    todos: [],
    session_id: nil,
    questions: nil,
    needs_input: false
  )
end

# File lib/rabbot_meta_agent.rb, line 209
def parse_stream(stdout, model:, status:, on_assistant_text: nil, partial_output: true)
  parser = StreamParser.new(
    model: model,
    on_assistant_text: on_assistant_text,
    partial_output: partial_output
  )
  stdout.to_s.each_line { |line| parser.ingest_line(line) }
  parser.to_result(status: status)
end

# File lib/rabbot_meta_agent.rb, line 119
def plan_prompt(prompt)
  text = prompt.to_s.strip
  return PLAN_PREFIX if text.empty?

  "#{PLAN_PREFIX}\n\n#{text}"
end

# File lib/rabbot_meta_agent.rb, line 152
def run(prompt, model:, workspace:, session_id: nil, on_assistant_text: nil, runner: nil,
        partial_output: true, trust: true, force: true, mode: :plan)
  args = build_args(
    prompt: prompt,
    model: model,
    workspace: workspace,
    session_id: session_id,
    partial_output: partial_output,
    trust: trust,
    force: force,
    mode: mode
  )

  result, stderr = if runner
                     stdout, err, status = runner.call(args)
                     [parse_stream(stdout, model: model, status: status, on_assistant_text: on_assistant_text,
                                   partial_output: partial_output), err]
                   else
                     execute_stream(args, model: model, on_assistant_text: on_assistant_text,
                                    partial_output: partial_output)
                   end

  result ||= interrupted_result(model: model, stderr: stderr)

  unless result.success?
    message = CursorAgentRunner.failure_message(
      stdout: result.text,
      stderr: stderr,
      fallback: "AI request failed"
    )
    result.error = message unless message.empty?
  end
  result
end