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

//! Runtime supervisor wrapping a parsed Workflow Definition schema.
//!
//! Where `WorkflowSchema` is parsed-only YAML, [`Workflow`] adds the
//! pieces that need a resolved file path: a [`Workspace`] anchored at
//! `workspace.root`, a [`HookRunner`] bound to this workflow, and helpers
//! that resolve other paths (prompt files, intake commands) relative to
//! the workflow file directory.
//!
//! The split lets `vik doctor` validate raw YAML through
//! [`crate::config::WorkflowSchema`] without instantiating the workspace
//! or pulling in the agent registry.
pub mod builder;
pub mod loader;

use std::path::{Path, PathBuf};

use indexmap::IndexMap;
use thiserror::Error;

use crate::config::diagnose::Diagnostics;
use crate::hooks::HookRunner;
use crate::utils;
use crate::workspace::Workspace;

pub use crate::config::*;

#[derive(Debug)]
pub struct Workflow {
  workflow_dir: PathBuf,
  workflow_path: PathBuf,
  schema: WorkflowSchema,
  workspace: Workspace,
  hooks: HookRunner,
}

impl Workflow {
  #[cfg(test)]
  pub fn load_from_str(yaml: &str) -> Result<Self, WorkflowError> {
    let loader = loader::WorkflowSchemaLoader.load_from_str(yaml, None)?;
    loader.try_into()
  }

  pub fn schema(&self) -> &WorkflowSchema {
    &self.schema
  }

  pub fn workspace(&self) -> &Workspace {
    &self.workspace
  }

  pub(crate) fn workflow_path(&self) -> &Path {
    &self.workflow_path
  }

  pub fn agents(&self) -> &AgentProfilesSchema {
    &self.schema.agents
  }

  pub fn stages(&self) -> &IndexMap<String, issue::IssueStage> {
    &self.schema.issue.stages
  }

  pub fn hooks(&self) -> &HookRunner {
    &self.hooks
  }

  /// Resolve a workflow-relative path string against the workflow file's
  /// directory. Used for prompt files, intake commands, anything declared
  /// in YAML as a relative path.
  pub fn resolve_path<P: AsRef<Path>>(&self, raw: P) -> Option<PathBuf> {
    utils::paths::resolve_from(&self.workflow_dir, raw)
  }
}

#[derive(Debug, Error)]
pub enum WorkflowError {
  #[error("Failed to resolve workflow path of {0}\n{1}")]
  PathResolution(PathBuf, #[source] std::io::Error),

  #[error("workflow file not found at {0}")]
  NotFound(PathBuf),

  #[error("workflow file {0} is a directory, expected a file")]
  IsDirectory(PathBuf),

  #[error("permission denied reading workflow file {0}")]
  PermissionDenied(PathBuf),

  #[error("Failed to read workflow file {0}\n{1}")]
  Read(PathBuf, #[source] std::io::Error),

  #[error("Failed to parse workflow YAML {0}\n{1}")]
  Yaml(PathBuf, #[source] serde_yaml::Error),

  #[error("invalid workflow config:\n{0}")]
  Diagnose(Diagnostics),

  #[error("workspace.root `{0}` could not be resolved")]
  WorkspaceRoot(PathBuf),
}