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