lumen 2.22.0

lumen is a command-line tool that uses AI to generate commit messages, summarise git diffs or past commits, and more.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use clap::Parser;
use command::LumenCommand;
use commit_reference::CommitReference;
use config::cli::{Cli, Commands};
use config::LumenConfig;
use error::LumenError;
use git_entity::{commit::Commit, diff::Diff, GitEntity};
use std::io::Read;
use std::process;
use vcs::VcsBackendType;

mod ai_prompt;
mod command;
mod commit_reference;
mod config;
mod error;
mod git_entity;
mod provider;
mod vcs;

#[tokio::main]
async fn main() {
    if let Err(e) = run().await {
        eprintln!("\x1b[91m\rerror:\x1b[0m {e}");
        process::exit(1);
    }
}

async fn run() -> Result<(), LumenError> {
    let cli = Cli::parse();

    let config = match LumenConfig::build(&cli) {
        Ok(config) => config,
        Err(e) => return Err(e),
    };

    let provider = provider::LumenProvider::new(config.provider, config.api_key, config.model)?;
    let command = command::LumenCommand::new(provider);

    // Get VCS backend based on CLI override or auto-detection
    let cwd = std::env::current_dir()?;
    let vcs_override = cli.vcs.map(VcsBackendType::from);
    let backend = vcs::get_backend(&cwd, vcs_override)?;

    match cli.command {
        Commands::Explain {
            reference,
            staged,
            query,
            list,
        } => {
            let git_entity = if list {
                let sha = LumenCommand::get_sha_from_fzf(backend.as_ref())?;
                let info = backend.get_commit(&sha)?;
                GitEntity::Commit(Commit::from_commit_info(info))
            } else {
                match reference {
                    Some(CommitReference::Single(input)) => {
                        let sha = if input == "-" {
                            read_from_stdin()?
                        } else {
                            input
                        };
                        let info = backend.get_commit(&sha)?;
                        GitEntity::Commit(Commit::from_commit_info(info))
                    }
                    Some(CommitReference::Range { from, to }) => {
                        let diff = backend.get_range_diff(&from, &to, false)?;
                        GitEntity::Diff(Diff::from_range_diff(diff, from, to)?)
                    }
                    Some(CommitReference::TripleDots { from, to }) => {
                        let diff = backend.get_range_diff(&from, &to, true)?;
                        GitEntity::Diff(Diff::from_range_diff(diff, from, to)?)
                    }
                    None => {
                        // Default: show uncommitted diff
                        let diff = backend.get_working_tree_diff(staged)?;
                        GitEntity::Diff(Diff::from_working_tree_diff(diff, staged)?)
                    }
                }
            };

            command
                .execute(command::CommandType::Explain { git_entity, query })
                .await?;
        }
        Commands::List => {
            eprintln!("Warning: 'lumen list' is deprecated. Use 'lumen explain --list' instead.");
            command
                .execute(command::CommandType::List {
                    backend: backend.as_ref(),
                })
                .await?
        }
        Commands::Draft { context } => {
            // Draft always uses staged diff (git convention)
            let diff = backend.get_working_tree_diff(true)?;
            let git_entity = GitEntity::Diff(Diff::from_working_tree_diff(diff, true)?);
            command
                .execute(command::CommandType::Draft {
                    git_entity,
                    context,
                    draft_config: config.draft,
                })
                .await?
        }
        Commands::Operate { query } => {
            command
                .execute(command::CommandType::Operate { query })
                .await?;
        }
        Commands::Diff {
            reference,
            pr,
            file,
            watch,
            theme,
            stacked,
            focus,
        } => {
            let options = command::diff::DiffOptions {
                reference,
                pr,
                file,
                watch,
                theme: theme.or(config.theme.clone()),
                stacked,
                focus,
            };
            command::diff::run_diff_ui(options, backend.as_ref())?;
        }
        Commands::Configure => {
            command::configure::ConfigureCommand::execute()?;
        }
    }

    Ok(())
}

fn read_from_stdin() -> Result<String, LumenError> {
    let mut buffer = String::new();
    std::io::stdin().read_to_string(&mut buffer)?;

    eprintln!("Reading commit SHA from stdin: '{}'", buffer.trim());
    Ok(buffer)
}