vik 0.1.0

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

use std::path::Path;

use minijinja::Value;
use serde::Serialize;
use serde_json::{Map, Value as JsonValue};

use crate::context::Issue;

pub struct Context {
  inner: Map<String, JsonValue>,
}

impl Context {
  /// Seeds `env` with the Vik process environment so templates can
  /// read `{{ env.VAR }}` without operators having to thread
  /// individual variables through.
  pub fn new() -> Self {
    let inner = serde_json::Map::new();
    let mut context = Self { inner };
    context.with_envs(std::env::vars());
    context
  }

  pub fn with<K: Into<String>, V: Serialize>(&mut self, key: K, value: V) -> &mut Self {
    self.inner.insert(
      key.into(),
      serde_json::to_value(value).unwrap_or(serde_json::Value::Null),
    );
    self
  }

  /// ```
  /// let base_context = Context::new().with("key1", "value1");
  ///
  /// let derived_context = base_context.derive();
  /// derived_context.with("key2", "value2");
  ///
  /// assert_eq!(base_context.build().get("key1").unwrap(), "value1");
  /// assert!(base_context.build().get("key2").is_none());
  ///
  /// assert_eq!(derived_context.build().get("key1").unwrap(), "value1");
  /// assert_eq!(derived_context.build().get("key2").unwrap(), "value2");
  /// ```
  #[allow(dead_code)]
  pub fn derive(&self) -> Self {
    Self {
      inner: self.inner.clone(),
    }
  }

  pub fn build(&self) -> Value {
    Value::from_serialize(&self.inner)
  }

  pub fn with_envs<It: Iterator<Item = (String, String)>>(&mut self, iter: It) {
    let entry = self.inner.entry("env");
    let value = entry.or_insert_with(|| JsonValue::Object(Map::new()));
    if let JsonValue::Object(map) = value {
      for (k, v) in iter {
        map.insert(k, JsonValue::String(v));
      }
    }
  }
}

/// Per-stage template inputs shared by hook and prompt renderers, so
/// the two surfaces cannot drift on what `cwd`/`workspace`/`issue`/
/// `stage` mean. Fields borrow from whatever the caller already holds —
/// no cloning forced here.
pub struct StageContext<'a> {
  pub issue: &'a Issue,
  pub stage_name: &'a str,
  pub agent_profile: &'a str,
  pub stage_state: &'a str,
  pub issue_workdir: &'a Path,
  pub workspace_root: &'a Path,
}

impl<'a> StageContext<'a> {
  /// Writes the canonical stage bindings on top of an existing
  /// context. The session renderer flattens issue payload first and
  /// then calls this so payload keys cannot shadow `cwd`/`stage`/etc.
  pub fn apply(&self, context: &mut Context) {
    context.with("cwd", self.issue_workdir.to_string_lossy().as_ref());
    context.with(
      "workspace",
      serde_json::json!({ "root": self.workspace_root.to_string_lossy() }),
    );
    context.with("issue", issue_value(self.issue, self.issue_workdir));
    context.with(
      "stage",
      serde_json::json!({
        "name": self.stage_name,
        "agent": self.agent_profile,
        "state": self.stage_state,
      }),
    );
  }

  pub fn build_template_context(&self) -> Context {
    let mut context = Context::new();
    self.apply(&mut context);
    context
  }

  pub fn build_template_context_with_cwd(&self) -> (Context, std::path::PathBuf) {
    (self.build_template_context(), self.issue_workdir.to_path_buf())
  }
}

/// `identifier` is added as a friendly alias for `id`, and `workdir`
/// only when a non-empty path is supplied — the `after_create` hook
/// fires before a stage workdir is bound, and we do not want operators
/// to reach for `issue.workdir` at that point in the lifecycle.
pub fn issue_value(issue: &Issue, issue_workdir: &Path) -> serde_json::Value {
  let mut value = serde_json::to_value(issue).unwrap_or(serde_json::Value::Null);
  if let serde_json::Value::Object(map) = &mut value {
    map.insert("identifier".to_string(), serde_json::Value::String(issue.id.clone()));
    let workdir = issue_workdir.to_string_lossy().into_owned();
    if !workdir.is_empty() {
      map
        .entry("workdir".to_string())
        .or_insert_with(|| serde_json::Value::String(workdir));
    }
  }
  value
}