patina-ai 0.23.0

Context orchestration for AI development - captures and evolves patterns over time
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
102
103

//! Version management for Patina projects
//!
//! This module follows the dependable-rust pattern:
//! - Public interface (this file): clean API for version operations
//! - Internal implementation: all logic in internal.rs
//!
//! # Versioning Model
//!
//! Patina uses semver: `MAJOR.MINOR.PATCH`
//!
//! Version bumps are driven by spec completion (`patina spec status <id> complete`)
//! via `ReleaseStrategy`. The version command provides `show` (display) and
//! `hotfix` (emergency escape hatch).
//!
//! # Example
//!
//! ```no_run
//! use patina::commands::version;
//!
//! // Show current version + ready specs
//! version::show(false, false).expect("Failed to show version");
//!
//! // Emergency patch (Cargo strategy only)
//! version::hotfix("fix critical auth bypass").expect("Failed to hotfix");
//! ```

mod internal;

use anyhow::Result;

/// Version CLI subcommands (used by main.rs via clap)
#[derive(Debug, Clone, clap::Subcommand)]
pub enum VersionCommands {
    /// Show current version and ready specs (default)
    Show {
        /// Output as JSON
        #[arg(short, long)]
        json: bool,

        /// Show component versions (git, external tools)
        #[arg(short, long)]
        components: bool,
    },

    /// Emergency patch bump without spec ceremony (Cargo strategy only)
    Hotfix {
        /// Description for the hotfix
        description: String,
    },
}

/// Execute version command from CLI arguments
///
/// Handles both subcommand form (`patina version show`) and
/// bare form (`patina version` defaults to show).
pub fn execute(json: bool, components: bool) -> Result<()> {
    show(json, components)
}

/// Execute version subcommand
pub fn execute_subcommand(command: VersionCommands) -> Result<()> {
    match command {
        VersionCommands::Show { json, components } => show(json, components),
        VersionCommands::Hotfix { description } => hotfix(&description),
    }
}

/// Show current version information
///
/// Displays the current version from Cargo.toml along with ready specs.
/// With `--components`, also shows git info and external tool versions.
pub fn show(json: bool, components: bool) -> Result<()> {
    internal::show_version(json, components)
}

/// Emergency patch bump without spec ceremony
///
/// Uses `ReleaseStrategy::preflight()` → `PreparedRelease::execute()` with
/// `BumpType::Patch`. Same safeguards as spec-driven releases. Cargo-only.
///
/// Prints a reminder to create a spec for traceability.
pub fn hotfix(description: &str) -> Result<()> {
    internal::hotfix(description)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_version_commands_variants() {
        let show = VersionCommands::Show {
            json: false,
            components: true,
        };
        assert!(matches!(show, VersionCommands::Show { .. }));

        let hotfix = VersionCommands::Hotfix {
            description: "fix critical bug".to_string(),
        };
        assert!(matches!(hotfix, VersionCommands::Hotfix { .. }));
    }
}