claude-code-toolkit 0.3.1

Claude Code management tool for credential sync, session monitoring, and GitHub integration
Documentation 
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

//! Setup and configuration wizard traits

use crate::error::Result;
use crate::types::Config;
use async_trait::async_trait;
use std::collections::HashMap;

/// Context for setup wizard steps
#[derive(Debug, Default)]
pub struct SetupContext {
  pub config: Config,
  pub user_input: HashMap<String, String>,
  pub flags: HashMap<String, bool>,
  pub step_results: HashMap<String, String>,
}

impl SetupContext {
  pub fn new() -> Self {
    Self::default()
  }

  pub fn set_input(&mut self, key: &str, value: &str) {
    self.user_input.insert(key.to_string(), value.to_string());
  }

  pub fn get_input(&self, key: &str) -> Option<&String> {
    self.user_input.get(key)
  }

  pub fn set_flag(&mut self, key: &str, value: bool) {
    self.flags.insert(key.to_string(), value);
  }

  pub fn get_flag(&self, key: &str) -> bool {
    self.flags.get(key).copied().unwrap_or(false)
  }

  pub fn set_result(&mut self, step: &str, result: &str) {
    self.step_results.insert(step.to_string(), result.to_string());
  }

  pub fn get_result(&self, step: &str) -> Option<&String> {
    self.step_results.get(step)
  }
}

/// Individual setup step
#[async_trait]
pub trait SetupStep: Send + Sync {
  /// Get step identifier
  fn step_id(&self) -> &str;

  /// Get step description
  fn description(&self) -> &str;

  /// Check if step can be skipped
  fn can_skip(&self, _context: &SetupContext) -> bool {
    false
  }

  /// Check if step prerequisites are met
  async fn check_prerequisites(&self, context: &SetupContext) -> Result<bool>;

  /// Execute the setup step
  async fn execute(&self, context: &mut SetupContext) -> Result<()>;

  /// Validate step results
  async fn validate(&self, context: &SetupContext) -> Result<bool>;

  /// Get next step recommendations
  fn next_steps(&self, _context: &SetupContext) -> Vec<String> {
    Vec::new()
  }
}

/// Setup wizard orchestrator
#[async_trait]
pub trait SetupWizard: Send + Sync {
  /// Get wizard name
  fn wizard_name(&self) -> &str;

  /// Get all setup steps
  fn get_steps(&self) -> Vec<Box<dyn SetupStep>>;

  /// Run complete setup wizard
  async fn run_setup(&self) -> Result<Config>;

  /// Run specific steps
  async fn run_steps(&self, step_ids: &[&str]) -> Result<Config>;

  /// Get setup progress
  fn get_progress(&self, context: &SetupContext) -> f32;

  /// Handle setup errors
  async fn handle_error(
    &self,
    step: &dyn SetupStep,
    error: &crate::error::ClaudeCodeError,
    context: &mut SetupContext
  ) -> Result<bool>;
}