call_coding_clis/
parser.rs

1use std::collections::BTreeMap;
2use std::sync::LazyLock;
3use std::sync::RwLock;
4
5const PERMISSION_MODES: &[&str] = &["safe", "auto", "yolo", "plan"];
6const PROMPT_MODES: &[&str] = &["default", "prepend", "append"];
7const OUTPUT_MODES: &[&str] = &[
8    "text",
9    "stream-text",
10    "json",
11    "stream-json",
12    "formatted",
13    "stream-formatted",
14];
15const KIMI_OUTPUT_MODES: &[&str] = &[
16    "text",
17    "stream-text",
18    "stream-json",
19    "formatted",
20    "stream-formatted",
21];
22const TEXT_OUTPUT_MODES: &[&str] = &["text", "stream-text"];
23
24#[derive(Clone, Debug)]
25pub struct RunnerInfo {
26    pub binary: String,
27    pub extra_args: Vec<String>,
28    pub no_persist_flags: Vec<String>,
29    pub thinking_flags: BTreeMap<i32, Vec<String>>,
30    pub show_thinking_flags: BTreeMap<bool, Vec<String>>,
31    pub yolo_flags: Vec<String>,
32    pub provider_flag: String,
33    pub model_flag: String,
34    pub agent_flag: String,
35    pub prompt_flag: String,
36}
37
38#[derive(Clone, Debug, Default)]
39pub struct ParsedArgs {
40    pub runner: Option<String>,
41    pub thinking: Option<i32>,
42    pub show_thinking: Option<bool>,
43    pub print_config: bool,
44    pub sanitize_osc: Option<bool>,
45    pub output_log_path: Option<bool>,
46    pub output_mode: Option<String>,
47    pub forward_unknown_json: bool,
48    pub save_session: bool,
49    pub cleanup_session: bool,
50    pub yolo: bool,
51    pub permission_mode: Option<String>,
52    pub provider: Option<String>,
53    pub model: Option<String>,
54    pub alias: Option<String>,
55    pub prompt: String,
56    pub prompt_supplied: bool,
57}
58
59#[derive(Clone, Debug)]
60pub struct AliasDef {
61    pub runner: Option<String>,
62    pub thinking: Option<i32>,
63    pub show_thinking: Option<bool>,
64    pub sanitize_osc: Option<bool>,
65    pub output_mode: Option<String>,
66    pub provider: Option<String>,
67    pub model: Option<String>,
68    pub agent: Option<String>,
69    pub prompt: Option<String>,
70    pub prompt_mode: Option<String>,
71}
72
73impl Default for AliasDef {
74    fn default() -> Self {
75        Self {
76            runner: None,
77            thinking: None,
78            show_thinking: None,
79            sanitize_osc: None,
80            output_mode: None,
81            provider: None,
82            model: None,
83            agent: None,
84            prompt: None,
85            prompt_mode: None,
86        }
87    }
88}
89
90#[derive(Clone, Debug)]
91pub struct CccConfig {
92    pub default_runner: String,
93    pub default_provider: String,
94    pub default_model: String,
95    pub default_thinking: Option<i32>,
96    pub default_show_thinking: bool,
97    pub default_sanitize_osc: Option<bool>,
98    pub default_output_mode: String,
99    pub aliases: BTreeMap<String, AliasDef>,
100    pub abbreviations: BTreeMap<String, String>,
101}
102
103impl Default for CccConfig {
104    fn default() -> Self {
105        Self {
106            default_runner: "oc".to_string(),
107            default_provider: String::new(),
108            default_model: String::new(),
109            default_thinking: Some(1),
110            default_show_thinking: true,
111            default_sanitize_osc: None,
112            default_output_mode: "text".to_string(),
113            aliases: BTreeMap::new(),
114            abbreviations: BTreeMap::new(),
115        }
116    }
117}
118
119#[derive(Clone, Debug, PartialEq, Eq)]
120pub struct OutputPlan {
121    pub runner_name: String,
122    pub mode: String,
123    pub stream: bool,
124    pub formatted: bool,
125    pub schema: Option<String>,
126    pub argv_flags: Vec<String>,
127    pub warnings: Vec<String>,
128}
129
130pub static RUNNER_REGISTRY: LazyLock<RwLock<BTreeMap<String, RunnerInfo>>> = LazyLock::new(|| {
131    let mut m = BTreeMap::new();
132    let opencode = RunnerInfo {
133        binary: "opencode".into(),
134        extra_args: vec!["run".into()],
135        no_persist_flags: vec![],
136        thinking_flags: BTreeMap::new(),
137        show_thinking_flags: {
138            let mut tf = BTreeMap::new();
139            tf.insert(true, vec!["--thinking".into()]);
140            tf
141        },
142        yolo_flags: vec![],
143        provider_flag: String::new(),
144        model_flag: String::new(),
145        agent_flag: "--agent".into(),
146        prompt_flag: String::new(),
147    };
148    let claude = RunnerInfo {
149        binary: "claude".into(),
150        extra_args: vec!["-p".into()],
151        no_persist_flags: vec!["--no-session-persistence".into()],
152        thinking_flags: {
153            let mut tf = BTreeMap::new();
154            tf.insert(0, vec!["--thinking".into(), "disabled".into()]);
155            tf.insert(
156                1,
157                vec![
158                    "--thinking".into(),
159                    "enabled".into(),
160                    "--effort".into(),
161                    "low".into(),
162                ],
163            );
164            tf.insert(
165                2,
166                vec![
167                    "--thinking".into(),
168                    "enabled".into(),
169                    "--effort".into(),
170                    "medium".into(),
171                ],
172            );
173            tf.insert(
174                3,
175                vec![
176                    "--thinking".into(),
177                    "enabled".into(),
178                    "--effort".into(),
179                    "high".into(),
180                ],
181            );
182            tf.insert(
183                4,
184                vec![
185                    "--thinking".into(),
186                    "enabled".into(),
187                    "--effort".into(),
188                    "max".into(),
189                ],
190            );
191            tf
192        },
193        show_thinking_flags: {
194            let mut tf = BTreeMap::new();
195            tf.insert(
196                true,
197                vec![
198                    "--thinking".into(),
199                    "enabled".into(),
200                    "--effort".into(),
201                    "low".into(),
202                ],
203            );
204            tf
205        },
206        yolo_flags: vec!["--dangerously-skip-permissions".into()],
207        provider_flag: String::new(),
208        model_flag: "--model".into(),
209        agent_flag: "--agent".into(),
210        prompt_flag: String::new(),
211    };
212    let kimi = RunnerInfo {
213        binary: "kimi".into(),
214        extra_args: vec![],
215        no_persist_flags: vec![],
216        thinking_flags: {
217            let mut tf = BTreeMap::new();
218            tf.insert(0, vec!["--no-thinking".into()]);
219            tf.insert(1, vec!["--thinking".into()]);
220            tf.insert(2, vec!["--thinking".into()]);
221            tf.insert(3, vec!["--thinking".into()]);
222            tf.insert(4, vec!["--thinking".into()]);
223            tf
224        },
225        show_thinking_flags: {
226            let mut tf = BTreeMap::new();
227            tf.insert(true, vec!["--thinking".into()]);
228            tf
229        },
230        yolo_flags: vec!["--yolo".into()],
231        provider_flag: String::new(),
232        model_flag: "--model".into(),
233        agent_flag: "--agent".into(),
234        prompt_flag: "--prompt".into(),
235    };
236    let codex = RunnerInfo {
237        binary: "codex".into(),
238        extra_args: vec!["exec".into()],
239        no_persist_flags: vec!["--ephemeral".into()],
240        thinking_flags: BTreeMap::new(),
241        show_thinking_flags: BTreeMap::new(),
242        yolo_flags: vec!["--dangerously-bypass-approvals-and-sandbox".into()],
243        provider_flag: String::new(),
244        model_flag: "--model".into(),
245        agent_flag: String::new(),
246        prompt_flag: String::new(),
247    };
248    let roocode = RunnerInfo {
249        binary: "roocode".into(),
250        extra_args: vec![],
251        no_persist_flags: vec![],
252        thinking_flags: BTreeMap::new(),
253        show_thinking_flags: BTreeMap::new(),
254        yolo_flags: vec![],
255        provider_flag: String::new(),
256        model_flag: String::new(),
257        agent_flag: String::new(),
258        prompt_flag: String::new(),
259    };
260    let crush = RunnerInfo {
261        binary: "crush".into(),
262        extra_args: vec!["run".into()],
263        no_persist_flags: vec![],
264        thinking_flags: BTreeMap::new(),
265        show_thinking_flags: BTreeMap::new(),
266        yolo_flags: vec![],
267        provider_flag: String::new(),
268        model_flag: String::new(),
269        agent_flag: String::new(),
270        prompt_flag: String::new(),
271    };
272    let cursor = RunnerInfo {
273        binary: "cursor-agent".into(),
274        extra_args: vec!["--print".into(), "--trust".into()],
275        no_persist_flags: vec![],
276        thinking_flags: BTreeMap::new(),
277        show_thinking_flags: BTreeMap::new(),
278        yolo_flags: vec!["--yolo".into()],
279        provider_flag: String::new(),
280        model_flag: "--model".into(),
281        agent_flag: String::new(),
282        prompt_flag: String::new(),
283    };
284    let gemini = RunnerInfo {
285        binary: "gemini".into(),
286        extra_args: vec![],
287        no_persist_flags: vec![],
288        thinking_flags: BTreeMap::new(),
289        show_thinking_flags: BTreeMap::new(),
290        yolo_flags: vec![],
291        provider_flag: String::new(),
292        model_flag: "--model".into(),
293        agent_flag: String::new(),
294        prompt_flag: "--prompt".into(),
295    };
296
297    let claude_clone = claude.clone();
298    let kimi_clone = kimi.clone();
299    let opencode_clone = opencode.clone();
300
301    let codex_clone = codex.clone();
302    let roocode_clone = roocode.clone();
303    let crush_clone = crush.clone();
304    let cursor_clone = cursor.clone();
305    let gemini_clone = gemini.clone();
306
307    m.insert("opencode".into(), opencode);
308    m.insert("claude".into(), claude);
309    m.insert("kimi".into(), kimi);
310    m.insert("codex".into(), codex);
311    m.insert("roocode".into(), roocode);
312    m.insert("crush".into(), crush);
313    m.insert("cursor".into(), cursor);
314    m.insert("gemini".into(), gemini);
315
316    m.insert("oc".into(), opencode_clone);
317    m.insert("cc".into(), claude_clone.clone());
318    m.insert("c".into(), codex_clone.clone());
319    m.insert("cx".into(), codex_clone);
320    m.insert("k".into(), kimi_clone);
321    m.insert("rc".into(), roocode_clone.clone());
322    m.insert("cr".into(), crush_clone);
323    m.insert("cu".into(), cursor_clone);
324    m.insert("g".into(), gemini_clone);
325
326    RwLock::new(m)
327});
328
329static RUNNER_SELECTOR_STRS: &[&str] = &[
330    "oc", "cc", "c", "cx", "k", "rc", "cr", "cu", "g", "codex", "claude", "opencode", "kimi",
331    "roocode", "crush", "cursor", "gemini",
332];
333
334fn is_runner_selector(s: &str) -> bool {
335    RUNNER_SELECTOR_STRS
336        .iter()
337        .any(|&sel| sel.eq_ignore_ascii_case(s))
338}
339
340fn parse_thinking(s: &str) -> Option<i32> {
341    let rest = s.strip_prefix('+')?;
342    match rest.to_ascii_lowercase().as_str() {
343        "0" | "none" => Some(0),
344        "1" | "low" => Some(1),
345        "2" | "med" | "mid" | "medium" => Some(2),
346        "3" | "high" => Some(3),
347        "4" | "max" | "xhigh" => Some(4),
348        _ => None,
349    }
350}
351
352fn parse_provider_model(s: &str) -> Option<(&str, &str)> {
353    let rest = s.strip_prefix(':')?;
354    let parts: Vec<&str> = rest.splitn(2, ':').collect();
355    if parts.len() == 2 {
356        Some((parts[0], parts[1]))
357    } else {
358        None
359    }
360}
361
362fn parse_model_only(s: &str) -> Option<&str> {
363    let rest = s.strip_prefix(':')?;
364    if rest.contains(':') {
365        None
366    } else {
367        Some(rest)
368    }
369}
370
371fn parse_alias(s: &str) -> Option<&str> {
372    let rest = s.strip_prefix('@')?;
373    if rest
374        .chars()
375        .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
376    {
377        Some(rest)
378    } else {
379        None
380    }
381}
382
383fn parse_output_mode(s: &str) -> Option<String> {
384    let mode = s.to_ascii_lowercase();
385    if OUTPUT_MODES.iter().any(|known| *known == mode) {
386        Some(mode)
387    } else {
388        None
389    }
390}
391
392fn parse_output_mode_sugar(s: &str) -> Option<String> {
393    match s.to_ascii_lowercase().as_str() {
394        ".text" => Some("text".to_string()),
395        "..text" => Some("stream-text".to_string()),
396        ".json" => Some("json".to_string()),
397        "..json" => Some("stream-json".to_string()),
398        ".fmt" => Some("formatted".to_string()),
399        "..fmt" => Some("stream-formatted".to_string()),
400        _ => None,
401    }
402}
403
404pub fn parse_args(argv: &[String]) -> ParsedArgs {
405    let mut parsed = ParsedArgs::default();
406    let mut positional: Vec<String> = Vec::new();
407    let mut force_prompt = false;
408    let mut index = 0;
409
410    while index < argv.len() {
411        let token = &argv[index];
412        if force_prompt || !positional.is_empty() {
413            positional.push(token.clone());
414        } else if token == "--" {
415            force_prompt = true;
416            index += 1;
417            continue;
418        } else if is_runner_selector(token) {
419            parsed.runner = Some(token.to_lowercase());
420        } else if let Some(level) = parse_thinking(token) {
421            parsed.thinking = Some(level);
422        } else if token == "--show-thinking" || token == "--no-show-thinking" {
423            parsed.show_thinking = Some(token == "--show-thinking");
424        } else if token == "--print-config" {
425            parsed.print_config = true;
426        } else if token == "--sanitize-osc" || token == "--no-sanitize-osc" {
427            parsed.sanitize_osc = Some(token == "--sanitize-osc");
428        } else if token == "--output-log-path" || token == "--no-output-log-path" {
429            parsed.output_log_path = Some(token == "--output-log-path");
430        } else if token == "--output-mode" || token == "-o" {
431            if index + 1 >= argv.len() {
432                parsed.output_mode = Some(String::new());
433            } else {
434                parsed.output_mode = Some(argv[index + 1].to_ascii_lowercase());
435                index += 1;
436            }
437        } else if token == "--forward-unknown-json" {
438            parsed.forward_unknown_json = true;
439        } else if token == "--save-session" {
440            parsed.save_session = true;
441        } else if token == "--cleanup-session" {
442            parsed.cleanup_session = true;
443        } else if let Some(mode) = parse_output_mode_sugar(token) {
444            parsed.output_mode = Some(mode);
445        } else if token == "--yolo" || token == "-y" {
446            parsed.yolo = true;
447            parsed.permission_mode = Some("yolo".to_string());
448        } else if token == "--permission-mode" {
449            if index + 1 >= argv.len() {
450                parsed.permission_mode = Some(String::new());
451            } else {
452                let mode = argv[index + 1].to_lowercase();
453                parsed.yolo = mode == "yolo";
454                parsed.permission_mode = Some(mode);
455                index += 1;
456            }
457        } else if let Some((provider, model)) = parse_provider_model(token) {
458            parsed.provider = Some(provider.to_string());
459            parsed.model = Some(model.to_string());
460        } else if let Some(model) = parse_model_only(token) {
461            parsed.model = Some(model.to_string());
462        } else if let Some(alias_name) = parse_alias(token) {
463            parsed.alias = Some(alias_name.to_string());
464        } else {
465            positional.push(token.clone());
466        }
467        index += 1;
468    }
469
470    parsed.prompt = positional.join(" ");
471    parsed.prompt_supplied = !positional.is_empty();
472    parsed
473}
474
475pub fn resolve_command(
476    parsed: &ParsedArgs,
477    config: Option<&CccConfig>,
478) -> Result<(Vec<String>, BTreeMap<String, String>, Vec<String>), String> {
479    let config = config.cloned().unwrap_or_default();
480    let registry = RUNNER_REGISTRY.read().unwrap();
481    let mut warnings = Vec::new();
482
483    let (effective_runner_name, effective_runner, alias_def) =
484        resolve_effective_runner(parsed, &config, &registry)
485            .ok_or_else(|| "no runner found".to_string())?;
486    if parsed.save_session && parsed.cleanup_session {
487        return Err("--save-session and --cleanup-session are mutually exclusive".to_string());
488    }
489
490    let mut argv: Vec<String> = vec![effective_runner.binary.clone()];
491    argv.extend(effective_runner.extra_args.iter().cloned());
492    warnings.extend(session_persistence_warnings(
493        parsed,
494        &effective_runner_name,
495        effective_runner,
496    ));
497    let output_plan = resolve_output_plan(parsed, Some(&config)).map_err(str::to_string)?;
498    warnings.extend(output_plan.warnings.clone());
499    argv.extend(output_plan.argv_flags.iter().cloned());
500
501    let effective_thinking = parsed
502        .thinking
503        .or_else(|| alias_def.and_then(|a| a.thinking))
504        .or(config.default_thinking);
505
506    let mut thinking_flags_applied = false;
507    if let Some(level) = effective_thinking {
508        if let Some(flags) = effective_runner.thinking_flags.get(&level) {
509            argv.extend(flags.iter().cloned());
510            thinking_flags_applied = true;
511        }
512    }
513
514    let effective_show_thinking = resolve_show_thinking(parsed, Some(&config));
515
516    if !thinking_flags_applied && effective_show_thinking {
517        if let Some(flags) = effective_runner.show_thinking_flags.get(&true) {
518            argv.extend(flags.iter().cloned());
519        }
520    }
521
522    let effective_provider: Option<String> = parsed
523        .provider
524        .clone()
525        .or_else(|| alias_def.and_then(|a| a.provider.clone()))
526        .or_else(|| {
527            if config.default_provider.is_empty() {
528                None
529            } else {
530                Some(config.default_provider.clone())
531            }
532        });
533
534    let effective_model: Option<String> = parsed
535        .model
536        .clone()
537        .or_else(|| alias_def.and_then(|a| a.model.clone()))
538        .or_else(|| {
539            if config.default_model.is_empty() {
540                None
541            } else {
542                Some(config.default_model.clone())
543            }
544        });
545
546    let mut env_overrides = BTreeMap::new();
547    if let Some(ref provider) = effective_provider {
548        env_overrides.insert("CCC_PROVIDER".to_string(), provider.clone());
549    }
550    if matches!(effective_runner_name.as_str(), "oc" | "opencode") {
551        env_overrides.insert(
552            "OPENCODE_DISABLE_TERMINAL_TITLE".to_string(),
553            "true".to_string(),
554        );
555    }
556
557    if let Some(ref model) = effective_model {
558        if !effective_runner.model_flag.is_empty() {
559            argv.push(effective_runner.model_flag.clone());
560            argv.push(model.clone());
561        }
562    }
563
564    let effective_agent = if let Some(alias_def) = alias_def {
565        alias_def.agent.clone()
566    } else if unresolved_alias_runner_name(parsed, &config, &registry).is_some() {
567        None
568    } else {
569        parsed.alias.clone()
570    };
571
572    if let Some(agent) = effective_agent {
573        if effective_runner.agent_flag.is_empty() {
574            warnings.push(format!(
575                "warning: runner \"{}\" does not support agents; ignoring @{}",
576                effective_runner_name, agent
577            ));
578        } else {
579            argv.push(effective_runner.agent_flag.clone());
580            argv.push(agent);
581        }
582    }
583
584    let effective_permission_mode = parsed.permission_mode.clone().or_else(|| {
585        if parsed.yolo {
586            Some("yolo".to_string())
587        } else {
588            None
589        }
590    });
591    if let Some(ref mode) = effective_permission_mode {
592        if mode.is_empty() {
593            return Err("permission mode requires one of: safe, auto, yolo, plan".to_string());
594        }
595        if !PERMISSION_MODES.iter().any(|known| known == mode) {
596            return Err("permission mode must be one of: safe, auto, yolo, plan".to_string());
597        }
598    }
599
600    if matches!(effective_permission_mode.as_deref(), Some("safe")) {
601        if matches!(effective_runner_name.as_str(), "cc" | "claude") {
602            argv.push("--permission-mode".to_string());
603            argv.push("default".to_string());
604        } else if matches!(effective_runner_name.as_str(), "oc" | "opencode") {
605            env_overrides.insert(
606                "OPENCODE_CONFIG_CONTENT".to_string(),
607                "{\"permission\":\"ask\"}".to_string(),
608            );
609        } else if matches!(effective_runner_name.as_str(), "cu" | "cursor") {
610            argv.push("--sandbox".to_string());
611            argv.push("enabled".to_string());
612        } else if matches!(effective_runner_name.as_str(), "g" | "gemini") {
613            argv.push("--approval-mode".to_string());
614            argv.push("default".to_string());
615            argv.push("--sandbox".to_string());
616        } else if matches!(effective_runner_name.as_str(), "rc" | "roocode") {
617            warnings.push(
618                "warning: runner \"roocode\" safe mode is unverified; leaving default permissions unchanged"
619                    .to_string(),
620            );
621        }
622    } else if matches!(effective_permission_mode.as_deref(), Some("auto")) {
623        if matches!(effective_runner_name.as_str(), "cc" | "claude") {
624            argv.push("--permission-mode".to_string());
625            argv.push("auto".to_string());
626        } else if matches!(effective_runner_name.as_str(), "c" | "cx" | "codex") {
627            argv.push("--full-auto".to_string());
628        } else if matches!(effective_runner_name.as_str(), "g" | "gemini") {
629            argv.push("--approval-mode".to_string());
630            argv.push("auto_edit".to_string());
631        } else {
632            warnings.push(format!(
633                "warning: runner \"{}\" does not support permission mode \"auto\"; ignoring it",
634                effective_runner_name
635            ));
636        }
637    } else if matches!(effective_permission_mode.as_deref(), Some("yolo")) {
638        if matches!(effective_runner_name.as_str(), "g" | "gemini") {
639            argv.push("--approval-mode".to_string());
640            argv.push("yolo".to_string());
641        } else if !effective_runner.yolo_flags.is_empty() {
642            argv.extend(effective_runner.yolo_flags.iter().cloned());
643        } else if matches!(effective_runner_name.as_str(), "oc" | "opencode") {
644            env_overrides.insert(
645                "OPENCODE_CONFIG_CONTENT".to_string(),
646                "{\"permission\":\"allow\"}".to_string(),
647            );
648        } else if matches!(effective_runner_name.as_str(), "cr" | "crush") {
649            warnings.push(
650                "warning: runner \"crush\" does not support yolo mode in non-interactive run mode; ignoring --yolo".to_string(),
651            );
652        } else if matches!(effective_runner_name.as_str(), "rc" | "roocode") {
653            warnings.push(
654                "warning: runner \"roocode\" yolo mode is unverified; ignoring --yolo".to_string(),
655            );
656        }
657    } else if matches!(effective_permission_mode.as_deref(), Some("plan")) {
658        if matches!(effective_runner_name.as_str(), "cc" | "claude") {
659            argv.push("--permission-mode".to_string());
660            argv.push("plan".to_string());
661        } else if matches!(effective_runner_name.as_str(), "k" | "kimi") {
662            argv.push("--plan".to_string());
663        } else if matches!(effective_runner_name.as_str(), "cu" | "cursor") {
664            argv.push("--mode".to_string());
665            argv.push("plan".to_string());
666        } else if matches!(effective_runner_name.as_str(), "g" | "gemini") {
667            argv.push("--approval-mode".to_string());
668            argv.push("plan".to_string());
669        } else {
670            warnings.push(format!(
671                "warning: runner \"{}\" does not support permission mode \"plan\"; ignoring it",
672                effective_runner_name
673            ));
674        }
675    }
676
677    if !parsed.save_session {
678        argv.extend(effective_runner.no_persist_flags.iter().cloned());
679    }
680
681    let prompt = resolve_prompt(parsed, alias_def)?;
682    if effective_runner.prompt_flag.is_empty() {
683        argv.push(prompt);
684    } else {
685        argv.push(effective_runner.prompt_flag.clone());
686        argv.push(prompt);
687    }
688
689    Ok((argv, env_overrides, warnings))
690}
691
692fn canonical_runner_name(effective_runner_name: &str, info: &RunnerInfo) -> String {
693    match effective_runner_name {
694        "oc" | "opencode" => "opencode".to_string(),
695        "cc" | "claude" => "claude".to_string(),
696        "c" | "cx" | "codex" => "codex".to_string(),
697        "k" | "kimi" => "kimi".to_string(),
698        "cr" | "crush" => "crush".to_string(),
699        "rc" | "roocode" => "roocode".to_string(),
700        "cu" | "cursor" => "cursor".to_string(),
701        "g" | "gemini" => "gemini".to_string(),
702        _ => info.binary.clone(),
703    }
704}
705
706fn session_persistence_warnings(
707    parsed: &ParsedArgs,
708    effective_runner_name: &str,
709    info: &RunnerInfo,
710) -> Vec<String> {
711    if parsed.save_session || !info.no_persist_flags.is_empty() {
712        return Vec::new();
713    }
714    let display = canonical_runner_name(effective_runner_name, info);
715    if parsed.cleanup_session {
716        if display == "opencode" || display == "kimi" {
717            return Vec::new();
718        }
719        return vec![format!(
720            "warning: runner \"{display}\" does not support automatic session cleanup; pass --save-session to allow saved sessions explicitly"
721        )];
722    }
723    Vec::new()
724}
725
726fn resolve_prompt(parsed: &ParsedArgs, alias_def: Option<&AliasDef>) -> Result<String, String> {
727    let user_prompt = parsed.prompt.trim();
728    let alias_prompt = alias_def
729        .and_then(|alias| alias.prompt.as_deref())
730        .map(str::trim)
731        .unwrap_or("");
732    let prompt_mode = alias_def
733        .and_then(|alias| alias.prompt_mode.as_deref())
734        .map(str::trim)
735        .filter(|mode| !mode.is_empty())
736        .unwrap_or("default");
737
738    if !PROMPT_MODES.iter().any(|known| *known == prompt_mode) {
739        return Err("prompt_mode must be one of: default, prepend, append".to_string());
740    }
741
742    if prompt_mode == "default" {
743        let prompt = if user_prompt.is_empty() {
744            alias_prompt
745        } else {
746            user_prompt
747        };
748        if prompt.is_empty() {
749            return Err("prompt must not be empty".to_string());
750        }
751        return Ok(prompt.to_string());
752    }
753
754    if !parsed.prompt_supplied {
755        return Err(format!(
756            "prompt_mode {prompt_mode} requires an explicit prompt argument"
757        ));
758    }
759    if alias_prompt.is_empty() {
760        let alias_name = parsed.alias.as_deref().unwrap_or("<alias>");
761        return Err(format!(
762            "prompt_mode {prompt_mode} requires aliases.{alias_name}.prompt"
763        ));
764    }
765
766    let mut parts = vec![alias_prompt, user_prompt];
767    if prompt_mode == "append" {
768        parts.reverse();
769    }
770    Ok(parts
771        .into_iter()
772        .filter(|part| !part.is_empty())
773        .collect::<Vec<_>>()
774        .join("\n"))
775}
776
777fn resolve_alias_def<'a>(parsed: &'a ParsedArgs, config: &'a CccConfig) -> Option<&'a AliasDef> {
778    parsed
779        .alias
780        .as_ref()
781        .and_then(|alias| config.aliases.get(alias))
782}
783
784fn unresolved_alias_runner_name(
785    parsed: &ParsedArgs,
786    config: &CccConfig,
787    registry: &BTreeMap<String, RunnerInfo>,
788) -> Option<String> {
789    if parsed.runner.is_some() {
790        return None;
791    }
792    let alias = parsed.alias.as_ref()?;
793    if config.aliases.contains_key(alias) {
794        return None;
795    }
796    let exact = resolve_runner_name(Some(alias), config);
797    if registry.contains_key(&exact) {
798        return Some(exact);
799    }
800    let lower_alias = alias.to_ascii_lowercase();
801    let lower = resolve_runner_name(Some(&lower_alias), config);
802    registry.contains_key(&lower).then_some(lower)
803}
804
805fn resolve_runner_name(parsed_runner: Option<&str>, config: &CccConfig) -> String {
806    let runner_name = parsed_runner.unwrap_or(&config.default_runner);
807    config
808        .abbreviations
809        .get(runner_name)
810        .cloned()
811        .unwrap_or_else(|| runner_name.to_string())
812}
813
814fn resolve_effective_runner<'a>(
815    parsed: &'a ParsedArgs,
816    config: &'a CccConfig,
817    registry: &'a BTreeMap<String, RunnerInfo>,
818) -> Option<(String, &'a RunnerInfo, Option<&'a AliasDef>)> {
819    let alias_def = resolve_alias_def(parsed, config);
820    let mut runner_name = resolve_runner_name(parsed.runner.as_deref(), config);
821    if parsed.runner.is_none() {
822        if let Some(alias_runner) = alias_def.and_then(|alias| alias.runner.as_deref()) {
823            runner_name = resolve_runner_name(Some(alias_runner), config);
824        } else if let Some(alias_runner) = unresolved_alias_runner_name(parsed, config, registry) {
825            runner_name = alias_runner;
826        }
827    }
828    let info = registry
829        .get(&runner_name)
830        .or_else(|| registry.get(&config.default_runner))
831        .or_else(|| registry.get("opencode"))?;
832    Some((runner_name, info, alias_def))
833}
834
835fn supported_output_modes(runner_name: &str) -> &'static [&'static str] {
836    match runner_name {
837        "cc" | "claude" | "oc" | "opencode" | "c" | "cx" | "codex" | "cu" | "cursor" => {
838            OUTPUT_MODES
839        }
840        "k" | "kimi" => KIMI_OUTPUT_MODES,
841        "g" | "gemini" => &[
842            "text",
843            "stream-text",
844            "json",
845            "stream-json",
846            "formatted",
847            "stream-formatted",
848        ],
849        _ => TEXT_OUTPUT_MODES,
850    }
851}
852
853fn fallback_output_mode(supported: &[&str]) -> &'static str {
854    if supported.iter().any(|mode| *mode == "text") {
855        "text"
856    } else {
857        "stream-text"
858    }
859}
860
861pub fn resolve_output_mode(
862    parsed: &ParsedArgs,
863    config: Option<&CccConfig>,
864) -> Result<String, &'static str> {
865    resolve_output_mode_with_source(parsed, config).map(|(mode, _)| mode)
866}
867
868fn resolve_output_mode_with_source(
869    parsed: &ParsedArgs,
870    config: Option<&CccConfig>,
871) -> Result<(String, &'static str), &'static str> {
872    let config = config.cloned().unwrap_or_default();
873    let alias_def = resolve_alias_def(parsed, &config);
874    let mut mode = parsed.output_mode.clone();
875    let mut source = "argument";
876    if mode.is_none() {
877        mode = alias_def.and_then(|alias| alias.output_mode.clone());
878        if mode.is_some() {
879            source = "alias";
880        }
881    }
882    let mode = mode.unwrap_or_else(|| {
883        source = "configured";
884        config.default_output_mode.clone()
885    });
886    if mode.is_empty() {
887        return Err(
888            "output mode requires one of: text, stream-text, json, stream-json, formatted, stream-formatted",
889        );
890    }
891    match parse_output_mode(&mode) {
892        Some(mode) => Ok((mode, source)),
893        None => Err(
894            "output mode must be one of: text, stream-text, json, stream-json, formatted, stream-formatted",
895        ),
896    }
897}
898
899pub fn resolve_show_thinking(parsed: &ParsedArgs, config: Option<&CccConfig>) -> bool {
900    let config = config.cloned().unwrap_or_default();
901    parsed
902        .show_thinking
903        .or_else(|| resolve_alias_def(parsed, &config).and_then(|alias| alias.show_thinking))
904        .unwrap_or(config.default_show_thinking)
905}
906
907pub fn resolve_sanitize_osc(parsed: &ParsedArgs, config: Option<&CccConfig>) -> bool {
908    let config = config.cloned().unwrap_or_default();
909    parsed
910        .sanitize_osc
911        .or_else(|| resolve_alias_def(parsed, &config).and_then(|alias| alias.sanitize_osc))
912        .or(config.default_sanitize_osc)
913        .unwrap_or_else(|| {
914            resolve_output_plan(parsed, Some(&config))
915                .map(|plan| plan.mode.contains("formatted"))
916                .unwrap_or(false)
917        })
918}
919
920pub fn resolve_output_plan(
921    parsed: &ParsedArgs,
922    config: Option<&CccConfig>,
923) -> Result<OutputPlan, &'static str> {
924    let config = config.cloned().unwrap_or_default();
925    let registry = RUNNER_REGISTRY.read().unwrap();
926    let (runner_name, info, _) =
927        resolve_effective_runner(parsed, &config, &registry).ok_or("no runner found")?;
928    let (mut mode, mode_source) = resolve_output_mode_with_source(parsed, Some(&config))?;
929    let supported = supported_output_modes(&runner_name);
930    let mut warnings = Vec::new();
931    if !supported.iter().any(|candidate| *candidate == mode) {
932        if mode_source == "argument" {
933            return Err("gemini runner does not support requested output mode");
934        }
935        let fallback = fallback_output_mode(supported);
936        warnings.push(format!(
937            "warning: runner \"{}\" does not support {} output mode \"{}\"; falling back to \"{}\"",
938            canonical_runner_name(&runner_name, info),
939            mode_source,
940            mode,
941            fallback,
942        ));
943        mode = fallback.to_string();
944    }
945
946    if matches!(mode.as_str(), "text" | "stream-text") {
947        return Ok(OutputPlan {
948            runner_name,
949            mode: mode.clone(),
950            stream: mode.starts_with("stream-"),
951            formatted: false,
952            schema: None,
953            argv_flags: Vec::new(),
954            warnings,
955        });
956    }
957
958    if matches!(runner_name.as_str(), "cc" | "claude") {
959        let mut argv_flags = if mode == "json" {
960            vec!["--output-format".into(), "json".into()]
961        } else {
962            vec![
963                "--verbose".into(),
964                "--output-format".into(),
965                "stream-json".into(),
966            ]
967        };
968        if mode == "stream-formatted" {
969            argv_flags.push("--include-partial-messages".into());
970        }
971        return Ok(OutputPlan {
972            runner_name,
973            mode: mode.clone(),
974            stream: mode.starts_with("stream-"),
975            formatted: mode.contains("formatted"),
976            schema: Some("claude-code".into()),
977            argv_flags,
978            warnings,
979        });
980    }
981
982    if matches!(runner_name.as_str(), "k" | "kimi") {
983        return Ok(OutputPlan {
984            runner_name,
985            mode: mode.clone(),
986            stream: mode.starts_with("stream-"),
987            formatted: mode.contains("formatted"),
988            schema: Some("kimi".into()),
989            argv_flags: vec![
990                "--print".into(),
991                "--output-format".into(),
992                "stream-json".into(),
993            ],
994            warnings,
995        });
996    }
997
998    if matches!(runner_name.as_str(), "oc" | "opencode") {
999        return Ok(OutputPlan {
1000            runner_name,
1001            mode: mode.clone(),
1002            stream: mode.starts_with("stream-"),
1003            formatted: mode.contains("formatted"),
1004            schema: Some("opencode".into()),
1005            argv_flags: vec!["--format".into(), "json".into()],
1006            warnings,
1007        });
1008    }
1009
1010    if matches!(runner_name.as_str(), "c" | "cx" | "codex") {
1011        return Ok(OutputPlan {
1012            runner_name,
1013            mode: mode.clone(),
1014            stream: mode.starts_with("stream-"),
1015            formatted: mode.contains("formatted"),
1016            schema: Some("codex".into()),
1017            argv_flags: vec!["--json".into()],
1018            warnings,
1019        });
1020    }
1021
1022    if matches!(runner_name.as_str(), "cu" | "cursor") {
1023        let argv_flags = if mode == "json" {
1024            vec!["--output-format".into(), "json".into()]
1025        } else {
1026            vec!["--output-format".into(), "stream-json".into()]
1027        };
1028        return Ok(OutputPlan {
1029            runner_name,
1030            mode: mode.clone(),
1031            stream: mode.starts_with("stream-"),
1032            formatted: mode.contains("formatted"),
1033            schema: Some("cursor-agent".into()),
1034            argv_flags,
1035            warnings,
1036        });
1037    }
1038
1039    if matches!(runner_name.as_str(), "g" | "gemini") {
1040        let argv_flags = if mode == "json" {
1041            vec!["--output-format".into(), "json".into()]
1042        } else {
1043            vec!["--output-format".into(), "stream-json".into()]
1044        };
1045        return Ok(OutputPlan {
1046            runner_name,
1047            mode: mode.clone(),
1048            stream: mode.starts_with("stream-"),
1049            formatted: mode.contains("formatted"),
1050            schema: Some("gemini".into()),
1051            argv_flags,
1052            warnings,
1053        });
1054    }
1055
1056    Ok(OutputPlan {
1057        runner_name,
1058        mode: mode.clone(),
1059        stream: mode.starts_with("stream-"),
1060        formatted: false,
1061        schema: None,
1062        argv_flags: Vec::new(),
1063        warnings,
1064    })
1065}
call_coding_clis/parser.rs

call_coding_clis/
parser.rs
