Class: Aidp::Execute::WorkLoopUnitScheduler

Inherits:
Object
  • Object
show all
Defined in:
lib/aidp/execute/work_loop_unit_scheduler.rb

Defined Under Namespace

Classes: Unit

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(units_config, project_dir:, clock: Time) ⇒ WorkLoopUnitScheduler

Returns a new instance of WorkLoopUnitScheduler.



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 22

def initialize(units_config, project_dir:, clock: Time)
  @clock = clock
  @project_dir = project_dir
  @deterministic_definitions = build_deterministic_definitions(units_config[:deterministic])
  @defaults = default_options.merge(units_config[:defaults] || {})
  @pending_units = []
  @initial_unit_requests = read_initial_unit_requests
  @deterministic_history = []
  @deterministic_state = Hash.new { |h, key| h[key] = default_deterministic_state }
  @agentic_runs = []
  @last_agentic_summary = nil
  @consecutive_deciders = 0
  @completed = false
  apply_initial_requests
  @started = @pending_units.any?
end

Instance Attribute Details

#last_agentic_summary ⇒ Object (readonly)

Returns the value of attribute last_agentic_summary.



20
21
22
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 20

def last_agentic_summary
  @last_agentic_summary
end

Instance Method Details

#completed? ⇒ Boolean

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 93

def completed?
  @completed
end

#deterministic_context(limit: 5) ⇒ Object 



89
90
91
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 89

def deterministic_context(limit: 5)
  @deterministic_history.last(limit)
end

#next_unit ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 39

def next_unit
  return nil if @completed

  unless @started
    @started = true
    queue_requested_unit(@defaults[:initial_unit] || :agentic)
  end

  unit = @pending_units.shift
  return unit if unit

  queue_requested_unit(@defaults[:on_no_next_step] || :agentic)

  @pending_units.shift
end

#record_agentic_result(result, requested_next: nil, summary: nil, completed: false) ⇒ Object 



55
56
57
58
59
60
61
62
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 55

def record_agentic_result(result, requested_next: nil, summary: nil, completed: false)
  @last_agentic_summary = summarize(summary)
  @agentic_runs << {timestamp: @clock.now, result: result}

  queue_requested_unit(requested_next) if requested_next

  mark_completed if completed && !requested_next
end

#record_deterministic_result(definition, result) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/aidp/execute/work_loop_unit_scheduler.rb', line 64

def record_deterministic_result(definition, result)
  state = @deterministic_state[definition.name]
  state[:last_run_at] = result.finished_at

  state[:current_backoff] = if result.success? || result.status == :event
    definition.min_interval_seconds
  else
    [
      state[:current_backoff] * definition.backoff_multiplier,
      definition.max_backoff_seconds
    ].min
  end

  @deterministic_history << {
    name: definition.name,
    status: result.status,
    output_path: result.output_path,
    finished_at: result.finished_at,
    data: result.data
  }

  requested = definition.next_for(result.status)
  queue_requested_unit(requested) if requested
end