claux 20260402.0.2

Terminal AI coding assistant with tool execution
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

mod api;
mod cli;
mod commands;
mod compact;
mod config;
mod context;
mod cost;
mod permissions;
mod query;
mod repl;
mod session;
mod tools;
mod tui;

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

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

    // Init logging
    let filter = if args.debug {
        "claux=debug"
    } else if args.verbose {
        "claux=info"
    } else {
        "claux=warn"
    };
    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_writer(std::io::stderr)
        .init();

    // Load config (global + project)
    let config = config::Config::load()?;

    let model = args
        .model
        .as_deref()
        .unwrap_or(&config.model)
        .to_string();

    tracing::debug!("Config loaded: openai_base_url={:?} openai_api_key_cmd={:?} model={}",
        config.openai_base_url, config.openai_api_key_cmd, config.model);

    // Build the provider
    let provider = build_provider(&config, &model)?;
    let provider_name = provider.name().to_string();
    tracing::info!("Provider: {} ({})", provider_name, model);

    // Build a factory for agent sub-providers
    let config_for_factory = config.clone();
    let model_for_factory = model.clone();
    let agent_factory: tools::agent::ProviderFactory = Box::new(move || {
        build_provider(&config_for_factory, &model_for_factory)
            .expect("failed to build agent provider")
    });

    // One-shot mode: --print / -p
    if let Some(ref prompt) = args.prompt {
        let tool_registry = tools::ToolRegistry::new_with_agent_factory(agent_factory, model.clone());
        let permission_checker = permissions::PermissionChecker::new(config.permission_mode);
        let mut engine = query::Engine::new(provider, tool_registry, permission_checker, &model);

        let system_prompt = context::build_system_prompt_for_model(&model).await?;
        engine.set_system_prompt(system_prompt);

        let response = engine.submit(prompt).await?;
        print!("{}", response);
        return Ok(());
    }

    // Interactive REPL
    let tool_registry = tools::ToolRegistry::new_with_agent_factory(agent_factory, model.clone());
    let permission_checker = permissions::PermissionChecker::new(config.permission_mode);
    let mut engine = query::Engine::new(provider, tool_registry, permission_checker, &model);

    // Resume a previous session if requested
    if let Some(ref session_id) = args.resume {
        let sessions = session::list_sessions()?;
        let found = sessions
            .iter()
            .find(|(sid, _)| sid == session_id || sid.starts_with(session_id));

        match found {
            Some((_, path)) => {
                let (meta, messages) = session::load_session(path)?;
                engine.set_messages(messages);
                eprintln!(
                    "Resumed session {} ({}, {} messages)",
                    meta.id,
                    meta.model,
                    engine.message_count()
                );
            }
            None => {
                eprintln!("Session not found: {}. Starting new session.", session_id);
            }
        }
    }

    if args.tui {
        tui::run(engine, &config).await
    } else {
        repl::run(engine, &config).await
    }
}

/// Build a provider from config.
fn build_provider(
    config: &config::Config,
    model: &str,
) -> Result<Box<dyn api::Provider>> {
    // Check for OpenAI-compatible provider in config
    if let Some(ref base_url) = config.openai_base_url {
        let api_key = config.resolve_openai_key().unwrap_or_default();
        let name = config.openai_provider_name.as_deref().unwrap_or("openai");
        return Ok(Box::new(api::OpenAICompatProvider::new(
            base_url, &api_key, model, name,
        )));
    }

    // Default: Anthropic
    let auth = config
        .resolve_auth()
        .ok_or_else(|| anyhow::anyhow!(
            "No authentication found. Set ANTHROPIC_API_KEY, configure ~/.config/claux/config.toml, or run `claude login`."
        ))?;

    Ok(Box::new(api::AnthropicProvider::new(auth, model)))
}