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