vik 0.1.1

Vik is an issue-driven coding workflow automation tool.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! In-memory registry of reserved and running stages.
//!
//! Owned exclusively by the orchestrator main loop — background tasks
//! report through events instead of mutating directly. Reservation lets
//! the main loop claim a stage key before spawning setup, which is what
//! prevents duplicate intake events from racing into a second launch.

use std::collections::{HashMap, HashSet};

use crate::context::{IssueStage, IssueStageKey};
use crate::session::{Session, SessionSnapshot};

pub(super) struct RunningMap {
  max_issue_concurrency: usize,
  stages: HashMap<IssueStageKey, RunningStage>,
}

impl RunningMap {
  pub(super) fn new(max_issue_concurrency: usize) -> Self {
    Self {
      max_issue_concurrency,
      stages: HashMap::new(),
    }
  }

  pub(super) fn is_empty(&self) -> bool {
    self.stages.is_empty()
  }

  pub(super) fn contains_key(&self, key: &IssueStageKey) -> bool {
    self.stages.contains_key(key)
  }

  /// A new stage for an already-running issue is always allowed. The
  /// concurrency cap counts distinct issue ids, not stages — an
  /// issue with three matching stages must not be blocked from its own
  /// stages by some other busy issue.
  pub(super) fn can_accept_issue(&self, issue_id: &str) -> bool {
    self.contains_issue(issue_id) || self.running_issue_count() < self.max_issue_concurrency
  }

  pub(super) fn reserve(&mut self, issue_stage: IssueStage) -> bool {
    let key = issue_stage.key();
    if self.contains_key(&key) || !self.can_accept_issue(&key.issue_id) {
      return false;
    }

    self.stages.insert(key, RunningStage::reserved(issue_stage));
    true
  }

  pub(super) fn start(&mut self, issue_stage: IssueStage, session: Session) {
    let key = issue_stage.key();
    let snapshot = session.snapshot();
    self
      .stages
      .entry(key)
      .and_modify(|stage| stage.start(session.clone(), snapshot.clone()))
      .or_insert_with(|| RunningStage::started(issue_stage, session, snapshot));
  }

  pub(super) fn update(&mut self, key: &IssueStageKey, snapshot: SessionSnapshot) {
    if let Some(stage) = self.stages.get_mut(key) {
      stage.snapshot = Some(snapshot);
    }
  }

  pub(super) fn finish(&mut self, key: &IssueStageKey, snapshot: SessionSnapshot) -> Option<RunningStage> {
    self.update(key, snapshot);
    self.stages.remove(key)
  }

  /// Removal path for setup/spawn failures. Distinct from `finish`
  /// because there is no terminal snapshot to record.
  pub(super) fn fail(&mut self, key: &IssueStageKey) -> Option<RunningStage> {
    self.stages.remove(key)
  }

  pub(super) fn cancel_all(&self) {
    for stage in self.stages.values() {
      if let Some(session) = &stage.session {
        session.cancel();
      }
    }
  }

  fn contains_issue(&self, issue_id: &str) -> bool {
    self.stages.values().any(|stage| stage.issue_stage.issue().id == issue_id)
  }

  /// Distinct issue ids, not stage entries — see `can_accept_issue`.
  fn running_issue_count(&self) -> usize {
    self
      .stages
      .values()
      .map(|stage| stage.issue_stage.issue().id.as_str())
      .collect::<HashSet<_>>()
      .len()
  }
}

/// `session = None` is the reservation marker — a key is claimed but no
/// session has spawned yet.
pub(super) struct RunningStage {
  pub(super) issue_stage: IssueStage,
  pub(super) session: Option<Session>,
  pub(super) snapshot: Option<SessionSnapshot>,
}

impl RunningStage {
  fn reserved(issue_stage: IssueStage) -> Self {
    Self {
      issue_stage,
      session: None,
      snapshot: None,
    }
  }

  fn started(issue_stage: IssueStage, session: Session, snapshot: SessionSnapshot) -> Self {
    Self {
      issue_stage,
      session: Some(session),
      snapshot: Some(snapshot),
    }
  }

  fn start(&mut self, session: Session, snapshot: SessionSnapshot) {
    self.session = Some(session);
    self.snapshot = Some(snapshot);
  }
}