mermaid-cli 0.3.10

Open-source AI pair programmer with agentic capabilities. Local-first with Ollama, native tool calling, and beautiful TUI.
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
104
105
106
107
108
109
110
111
112
113
114
115
116

use anyhow::Result;
use clap::Parser;

use mermaid_cli::{
    app::{load_config, persist_last_model},
    cli::{Cli, Commands, OutputFormat},
    ollama::{ensure_model as ensure_ollama_model, require_any_model},
    runtime::{NonInteractiveRunner, Orchestrator},
    utils::init_logger,
};

#[tokio::main]
async fn main() -> Result<()> {
    // Parse CLI arguments
    let cli = Cli::parse();

    // Initialize tracing subscriber (controlled by --verbose flag or RUST_LOG env var)
    init_logger(cli.verbose);

    // Check for Run subcommand (non-interactive mode)
    if let Some(Commands::Run {
        prompt,
        format,
        max_tokens,
        no_execute,
    }) = &cli.command
    {
        return run_non_interactive(&cli, prompt.clone(), *format, *max_tokens, *no_execute).await;
    }

    // Create and run the orchestrator for interactive mode
    let orchestrator = Orchestrator::new(cli)?;
    orchestrator.run().await
}

/// Run in non-interactive mode
async fn run_non_interactive(
    cli: &Cli,
    prompt: String,
    format: OutputFormat,
    max_tokens: Option<usize>,
    no_execute: bool,
) -> Result<()> {
    // Load configuration
    let config = load_config().unwrap_or_default();

    // Determine model to use (CLI arg > last_used > default_model)
    let cli_model_provided = cli.model.is_some();
    let model_id = if let Some(model) = &cli.model {
        model.clone()
    } else if let Some(last_model) = &config.last_used_model {
        last_model.clone()
    } else if !config.default_model.provider.is_empty()
        && !config.default_model.name.is_empty()
    {
        format!(
            "{}/{}",
            config.default_model.provider, config.default_model.name
        )
    } else {
        // No model configured - check if any models are available
        let available = require_any_model().await?;
        format!("ollama/{}", available[0])
    };

    // Validate model exists
    ensure_ollama_model(&model_id, true).await?;

    // Persist model if CLI flag was used
    if cli_model_provided {
        let _ = persist_last_model(&model_id);
    }

    // Determine project path
    let project_path = cli
        .path
        .clone()
        .unwrap_or_else(|| std::path::PathBuf::from("."));

    // Use CLI args if provided, otherwise fall back to config
    let effective_max_tokens = max_tokens.or(Some(config.non_interactive.max_tokens));
    let effective_no_execute = no_execute || config.non_interactive.no_execute;

    // Get backend from config (clone to avoid borrow issues)
    let backend_str = config.behavior.backend.clone();
    let backend = if backend_str == "auto" {
        None
    } else {
        Some(backend_str.as_str())
    };

    // Create and run the non-interactive runner
    let runner = NonInteractiveRunner::new(
        model_id,
        project_path,
        config,
        effective_no_execute,
        effective_max_tokens,
        backend,
    )
    .await?;

    // Execute the prompt
    let result = runner.execute(prompt).await?;

    // Format and output the result
    let formatted = runner.format_result(&result, format);
    println!("{}", formatted);

    // Exit with appropriate code
    if !result.errors.is_empty() {
        std::process::exit(1);
    }

    Ok(())
}