1mod compact;
  2mod create;
  3mod dep;
  4mod done;
  5mod export;
  6mod import;
  7mod init;
  8mod label;
  9mod list;
 10mod next;
 11mod ready;
 12mod reopen;
 13mod search;
 14mod show;
 15mod skill;
 16mod stats;
 17mod update;
 18
 19use crate::cli::{Cli, Command};
 20use crate::db;
 21use anyhow::Result;
 22
 23fn require_root() -> Result<std::path::PathBuf> {
 24    db::find_root(&std::env::current_dir()?)
 25}
 26
 27pub fn dispatch(cli: &Cli) -> Result<()> {
 28    match &cli.command {
 29        Command::Init { stealth } => {
 30            let root = std::env::current_dir()?;
 31            init::run(&root, *stealth, cli.json)
 32        }
 33        Command::Create {
 34            title,
 35            priority,
 36            effort,
 37            task_type,
 38            desc,
 39            parent,
 40            labels,
 41        } => {
 42            let root = require_root()?;
 43            create::run(
 44                &root,
 45                create::Opts {
 46                    title: title.as_deref(),
 47                    priority: db::parse_priority(priority)?,
 48                    effort: db::parse_effort(effort)?,
 49                    task_type,
 50                    desc: desc.as_deref(),
 51                    parent: parent.as_deref(),
 52                    labels: labels.as_deref(),
 53                    json: cli.json,
 54                },
 55            )
 56        }
 57        Command::List {
 58            status,
 59            priority,
 60            effort,
 61            label,
 62        } => {
 63            let root = require_root()?;
 64            let pri = priority.as_deref().map(db::parse_priority).transpose()?;
 65            let eff = effort.as_deref().map(db::parse_effort).transpose()?;
 66            list::run(
 67                &root,
 68                status.as_deref(),
 69                pri,
 70                eff,
 71                label.as_deref(),
 72                cli.json,
 73            )
 74        }
 75        Command::Show { id } => {
 76            let root = require_root()?;
 77            show::run(&root, id, cli.json)
 78        }
 79        Command::Update {
 80            id,
 81            status,
 82            priority,
 83            effort,
 84            title,
 85            desc,
 86        } => {
 87            let root = require_root()?;
 88            let pri = priority.as_deref().map(db::parse_priority).transpose()?;
 89            let eff = effort.as_deref().map(db::parse_effort).transpose()?;
 90            update::run(
 91                &root,
 92                id,
 93                update::Opts {
 94                    status: status.as_deref(),
 95                    priority: pri,
 96                    effort: eff,
 97                    title: title.as_deref(),
 98                    desc: desc.as_deref(),
 99                    json: cli.json,
100                },
101            )
102        }
103        Command::Done { ids } => {
104            let root = require_root()?;
105            done::run(&root, ids, cli.json)
106        }
107        Command::Reopen { ids } => {
108            let root = require_root()?;
109            reopen::run(&root, ids, cli.json)
110        }
111        Command::Dep { action } => {
112            let root = require_root()?;
113            dep::run(&root, action, cli.json)
114        }
115        Command::Label { action } => {
116            let root = require_root()?;
117            label::run(&root, action, cli.json)
118        }
119        Command::Search { query } => {
120            let root = require_root()?;
121            search::run(&root, query, cli.json)
122        }
123        Command::Ready => {
124            let root = require_root()?;
125            ready::run(&root, cli.json)
126        }
127        Command::Next {
128            mode,
129            verbose,
130            limit,
131        } => {
132            let root = require_root()?;
133            next::run(&root, mode, *verbose, *limit, cli.json)
134        }
135        Command::Stats => {
136            let root = require_root()?;
137            stats::run(&root)
138        }
139        Command::Compact => {
140            let root = require_root()?;
141            compact::run(&root)
142        }
143        Command::Export => {
144            let root = require_root()?;
145            export::run(&root)
146        }
147        Command::Import { file } => {
148            let root = require_root()?;
149            import::run(&root, file)
150        }
151        Command::Skill { dir } => skill::run(dir.as_deref()),
152    }
153}