pmat 3.16.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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

// Mutating operations on configuration: set values, edit interactively, reset to defaults.
// Includes: set_configuration_values, edit_configuration, reset_configuration.

/// Set configuration values
async fn set_configuration_values(
    config_service: &ConfigurationService,
    set_values: Vec<String>,
) -> Result<()> {
    info!("Updating configuration values");

    for set_value in set_values {
        let parts: Vec<&str> = set_value.splitn(2, '=').collect();
        if parts.len() != 2 {
            return Err(anyhow::anyhow!(
                "Invalid format '{set_value}'. Use key=value"
            ));
        }

        let key = parts[0];
        let value = parts[1];

        println!("Setting {key}: {value}");

        config_service
            .update_config(|config| set_config_value(config, key, value))
            .await?;
    }

    println!("Configuration updated successfully");
    Ok(())
}

/// Edit configuration interactively
async fn edit_configuration(config_service: &ConfigurationService) -> Result<()> {
    println!("Interactive Configuration Editor");
    println!("{}", "=".repeat(40));
    println!();

    let config = config_service.get_config()?;
    let toml_content = toml::to_string_pretty(&config)?;

    // Create temporary file with current config
    let temp_dir = tempfile::tempdir()?;
    let temp_file = temp_dir.path().join("pmat_config.toml");
    tokio::fs::write(&temp_file, &toml_content).await?;

    // Detect editor
    let editor = std::env::var("EDITOR")
        .or_else(|_| std::env::var("VISUAL"))
        .unwrap_or_else(|_| "nano".to_string());

    println!("Opening configuration in {editor} editor...");
    println!("Save and exit to apply changes, or exit without saving to cancel.");
    println!();

    // Open editor
    let status = std::process::Command::new(&editor)
        .arg(&temp_file)
        .status()?;

    if !status.success() {
        return Err(anyhow::anyhow!("Editor exited with error"));
    }

    // Read edited content
    let edited_content = tokio::fs::read_to_string(&temp_file).await?;

    // Parse and validate
    let new_config: PmatConfig = toml::from_str(&edited_content)?;

    // Update configuration
    config_service
        .update_config(|config| {
            *config = new_config;
            Ok(())
        })
        .await?;

    println!("Configuration updated successfully");
    Ok(())
}

/// Reset configuration to defaults
async fn reset_configuration(config_service: &ConfigurationService) -> Result<()> {
    info!("Resetting configuration to defaults");

    config_service
        .update_config(|config| {
            *config =
                crate::services::configuration_service::ConfigurationService::default_config();
            Ok(())
        })
        .await?;

    Ok(())
}