taskai-cli 1.5.4__tar.gz → 1.6.2__tar.gz

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/DEVLOG.md

@@ -1,3 +1,119 @@
+# 8-22
+
+Found and fixed a real bug from the `litellm` migration earlier today: it
+auto-loads `.env` via `python-dotenv` on import, and the project's `.env`
+had a stray first line (`source .taskai-venv/bin/activate` — not a
+`KEY=VALUE` pair), so every `task ai` run printed a "could not parse
+statement starting at line 1" warning. Non-fatal (`GEMINI_API_KEY` on line
+2 still loaded fine) but confusing. Diagnosed by reading `litellm/__init__.py`
+directly rather than guessing — it calls `_dotenv.load_dotenv(...)` at
+import time. Left the actual `.env` edit to Alex since it holds a live key.
+
+Also stripped two leftover debug `print()`s from `ai_natural_language_service`
+(the raw prompt and the full constructed `ai_prompt` — fine for iterating on
+the prompt, noise now that this is a user-facing command) and reworked the
+"about to run these commands" printout: instead of one `print(response_json)`
+dump of the raw parsed list, it now prints each command right before running
+it, reconstructed as `ai run 'task <command> ...'` (quoting only values with
+spaces) via a small `_format_command_str()` helper — reads like a real
+command instead of a dict dump, and shows progress as it goes rather than
+front-loading everything.
+
+Added `--context` and `--reasoning` to `task ai <prompt>` (DEVPLAN 2.2,
+below, has the durable version of this):
+
+- `--context a.md,b.md` reads file(s) and folds them into the prompt.
+- While wiring it up, found `execute_commands`'s `case "ai":` dispatch
+  never forwarded `**kwargs` to `Controller.ai_natural_language` at all —
+  `--context` would've parsed fine and then been silently dropped before
+  reaching the service. Fixed by threading `**kwargs` through the whole
+  chain (`cli.py`'s dispatch → `Controller.ai_natural_language` →
+  `ai_natural_language_service`).
+- `--reasoning <level>` came out of a tangent about `task ai` latency: Alex
+  asked whether "respond quickly" in the prompt does anything (no — output
+  token generation is sequential/autoregressive, prompt wording can't speed
+  that up) and what actually causes it. Real answer: some Gemini tiers
+  generate a hidden "thinking" pass before the visible output, which is a
+  genuine invisible latency cost. Read litellm's Gemini transformation
+  source directly to confirm the actual knob: `reasoning_effort` is a
+  standard litellm kwarg on `completion()`, mapped per-provider — accepts
+  `minimal|low|medium|high|disable|none`. Confirmed a real wrinkle for this
+  project specifically: on Gemini 2.5-series models it maps to a
+  `thinkingBudget` token count and `"none"` zeroes it out completely, but
+  on Gemini 3.x (what `llm_models.py`'s menu defaults to) it maps to a
+  `thinkingLevel` enum, and litellm's own code comment says Gemini 3
+  *cannot* fully disable thinking — `"disable"`/`"none"` just fall back to
+  the minimum level there. Only exposed for reasoning-capable tiers
+  (`supports_reasoning(...)` gated internally), so it may no-op or error on
+  something like Flash-Lite.
+- Tried defaulting `--reasoning` to `"disable"` when omitted, then Alex
+  reverted that — omitting the flag now sends no `reasoning_effort` at all,
+  leaving it up to whatever the model/provider defaults to.
+- Documented both flags under `task ai` in `help_menu.py` (this file is
+  also the AI's own command reference, so it needs to stay accurate even
+  though neither flag is something the model itself would ever emit).
+
+---
+
+Migrated AI backend off direct `google-genai` calls, landing on `litellm`
+after a detour through `aisuite`:
+
+- First tried `aisuite` per DEVPLAN's original Phase 2 plan. Downloaded and
+  read the actual package source before committing to it (not just docs) —
+  found `aisuite`'s only Google provider is Vertex AI
+  (`GOOGLE_PROJECT_ID`/`GOOGLE_REGION`/a service-account JSON), with no path
+  to a plain Gemini/AI-Studio API key. Since the existing setup is just a
+  simple API key, that would've been a real functionality change disguised
+  as a library swap. Flagged it to Alex before writing any code.
+- Alex opted to rework the setup rather than force-fit the old flow, but
+  then asked whether another compat layer supported plain Gemini API keys —
+  it does: `litellm` treats `gemini` and `vertex_ai` as separate providers
+  (confirmed by reading `litellm/utils.py`'s `validate_environment` and
+  `litellm/types/utils.py`'s `LlmProviders` enum directly), so
+  `gemini/<model>` + `GEMINI_API_KEY` keeps the current simple setup working
+  end to end. Redid the migration against `litellm` instead.
+- `pyproject.toml`: `google-genai` → `litellm>=1.98`.
+- `taskai/models.py`: `CLIConfig.GEMINI_MODEL`/`GEMINI_API_KEY` collapsed to
+  a single `AI_MODEL: str` (a `provider/model` string, litellm's own
+  separator).
+- `taskai/services/ai.py`: both `ai_headstart_service` and
+  `ai_natural_language_service` now call
+  `litellm.completion(model=model_name, messages=[...])` instead of
+  `google.genai`; dropped the `api_key`/`@config("GEMINI_API_KEY", ...)`
+  plumbing since litellm reads provider credentials straight from env vars.
+- New [taskai/llm_models.py](taskai/llm_models.py) (top-level, not under
+  `services/` — it's reference data, not a service): `PROVIDER_ENV_VARS`
+  (which env var(s) litellm expects per provider) and `PROVIDER_MODELS` (a
+  best-effort, non-exhaustive menu of known models per provider). Both
+  built by reading litellm's source directly rather than guessing.
+- `services/user_setup.py` reworked into a two-step picker
+  (`_select_from_list`): pick a provider from a numbered menu, then pick a
+  model for that provider from another numbered menu. Either step also
+  accepts free-typed text instead of a number, so a stale/missing
+  `PROVIDER_MODELS` entry (several providers — `azure`, `ollama` — are
+  intentionally empty, since their "models" are a deployment name or
+  whatever you've pulled locally) never blocks setup.
+- Caught a live example of "models go stale fast" mid-session: Alex hit
+  `gemini-3.6-flash` referenced by Google's own tooling, which wasn't in
+  training data. Web-searched Google's current model docs and corrected the
+  `gemini`/`vertex_ai` entries in `llm_models.py` — `gemini-2.0-flash` (the
+  old hardcoded default) was actually shut down 2026-06-01. If `task
+  setup`'s Gemini options look wrong again, re-check against
+  https://ai.google.dev/gemini-api/docs/models rather than trusting the
+  hardcoded list.
+- README's Config section updated to match (`AI_MODEL` as `provider/model`,
+  points at `task setup`).
+- Not yet done: `pip install "litellm>=1.98"` / `pip uninstall google-genai`
+  in `.taskai-venv` — Alex needs to run this manually (environment-mutating
+  commands aren't run unprompted in this project).
+
+DEVPLAN.md's Phase 2 (2.1, 2.3) updated to match — checked off, `aisuite`
+references swapped for `litellm`, and 2.4 (the later tool-calling-loop
+entry point) flagged for re-scoping since it was written around `aisuite`'s
+automatic tool-runner, which `litellm` has no equivalent for.
+
+---
+
 # 8-19
 
 Fixed a typo in `browser.py` that caused uvicorn to fail with "Could not import

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/DEVPLAN.md

@@ -24,10 +24,10 @@ depth, and the same node type is used whether it's acting as a "list" or a
 (`recurs_every`/`recurs_until`/`recur_keep_incomplete`). `Comment` is a
 simple `{content, item_id, created_on}`. `UserData` is the whole-DB
 container: `todo_items: dict[str, dict]`, `comments: dict[str, dict]`,
-`config: dict`, `id_counter`. `CLIConfig` currently holds
-`GEMINI_MODEL`/`GEMINI_API_KEY` (Phase 2 below plans migrating this to a
-single `AI_MODEL` field once `aisuite` lands) plus `DISPLAY_STRING`/
-`DISPLAY_COLORS` for CLI rendering.
+`config: dict`, `id_counter`. `CLIConfig` holds a single `AI_MODEL` field (a
+`provider/model` string, e.g. `gemini/gemini-3.6-flash` — set via `task
+setup`'s two-step provider→model picker, done in Phase 2) plus
+`DISPLAY_STRING`/`DISPLAY_COLORS` for CLI rendering.
 
 **Storage.** [taskai/json_dir_database.py](taskai/json_dir_database.py):
 `JsonDirectoryDatabase` — one JSON file per user under `.taskai/task_db/
@@ -64,9 +64,11 @@ opening a second connection.
 `ai_headstart_service` (single item → LLM suggests a next concrete step,
 saved as a comment) and `ai_natural_language_service` (prompt → LLM returns
 a JSON list of `{command, args, kwargs}` → executed through
-`taskai.cli.execute_commands`, one call per entry). Both currently call
-Gemini directly via `google-genai`; Phase 2 below covers migrating to
-`aisuite`. The natural-language prompt embeds
+`taskai.cli.execute_commands`, one call per entry). Both call
+`litellm.completion(model=model_name, messages=[...])` — provider-agnostic
+per the `AI_MODEL` config value, no more hardcoded Gemini/`google-genai`.
+See [taskai/llm_models.py](taskai/llm_models.py) for the provider→env-var
+and provider→model reference data `task setup` uses. The natural-language prompt embeds
 [taskai/help_menu.py](taskai/help_menu.py)'s `help_general` string as the
 LLM's command reference — **that file is the single source of truth for the
 command surface, shown to humans via `task help` and to the LLM verbatim.
@@ -75,12 +77,19 @@ it's gone stale before.
 
 **Known code quirks (found but intentionally not fixed — out of scope
 unless you're told to fix them):**
-- `Controller.update_item` (`cli.py`) resolves a non-numeric `item_id` via
+- ~~`Controller.update_item` (`cli.py`) resolves a non-numeric `item_id` via
   `_find_model_by_stringmatch` but assigns the *whole model object* back
-  into `item_id` instead of pulling `.id` off it, so it's passed down to
-  `db.update_item` as a model, not an id, and fails. This means `update`,
-  `rename`, and `status` (all three route through `update_item`) only work
-  reliably with a numeric id, not a name.
+  into `item_id` instead of pulling `.id` off it~~ **Fixed.** All identifier
+  resolution (id or name) now routes through one function,
+  `Controller._resolve_item()` (throws via `throw_error` if not found; a
+  non-throwing `_find_item_by_identifier` still backs the soft-fail `show`
+  path). Every command that takes an item identifier — `update`, `rename`,
+  `status`, `done`/`complete`, `comment`, `depend`, `reorder`, `move`,
+  `link`, `delete`, `create`'s parent — now accepts a name via `fnmatch`,
+  not just a numeric id. Net effect was less code, not more: two
+  name-only-duplicate methods (`show_by_item_name`, `delete_item_by_name`)
+  and several inline `_is_int(...)` dispatch branches in `execute_commands`
+  were deleted outright rather than kept alongside the id path.
 - `task show <id1>,<id2>,...` is documented in the README but
   `execute_commands`'s `show` case never dispatches to
   `Controller.show_items`/`view_items` — there's no wired path to it.
@@ -336,48 +345,152 @@ through the existing `Controller`.
 
 ## Phase 2 — AI tools
 
-### 2.1 — Finish the natural-language service
-
-- [ ] Depends on Phase 0 fixes (prompt bug, `_add_info` bug, actually
-      executing parsed commands).
-- [ ] Add the ability to inject extra context / tools / other agentic framework arguments
-      supported by aisuite. 
-- [ ] Have execution reuse the *same* command-string path as the web console
-      (`execute_commands`, or the `/api/command` handler once it exists) so
-      AI-issued commands and human-issued commands share one code path.
-- [ ] Print the parsed command list before executing it (already partially
-      there via `print(response_json)`) — cheap safety net given the parsed
-      commands can include `delete`/`nuke`. Not a full confirmation prompt,
-      just visibility.
-
-### 2.2 — Switch to `aisuite`
-
-- [ ] Add `aisuite` to `pyproject.toml` dependencies; drop the direct
-      `google-genai` import from `services/ai.py`.
-- [ ] Replace both call sites (`ai_headstart_service`,
-      `ai_natural_language_service`) with `aisuite.Client()` and
-      `client.chat.completions.create(model=model_name, messages=[...])`.
-      Model strings become `provider:model`, e.g. `google:gemini-2.0-flash`
-      or `openai:gpt-4o-mini` — this is what buys multi-provider support for
-      free.
-- [ ] `aisuite` reads provider credentials from standard provider env vars
-      (`OPENAI_API_KEY`, `GOOGLE_API_KEY`, etc.), not from a key you pass in.
-      Drop the `@config("GEMINI_API_KEY", "api_key")` plumbing entirely —
+Two entry points, built in stages, not one replacing the other:
+**`task ai <prompt>`** (2.1-2.3 below) is the existing one-shot flow —
+model sees the prompt once, returns a full JSON list of commands up front,
+they execute with no gating, same as today just on `litellm`. **`task ai
+agent <prompt>`** (2.4, later) is a separate, more elaborate entry point for
+multi-step workflows using a real tool-calling loop, added only after 2.1-2.3
+are working and any kinks (context injection, multi-file support) are worked
+out on the simpler path first.
+
+### 2.1 — `task ai <prompt>` on `litellm` (no gating, same one-shot shape as today)
+
+- [x] Depended on the Phase 0 fixes (prompt bug, `_add_info` bug, actually
+      executing parsed commands) — done.
+- [x] Originally planned on `aisuite` (below was written for it), but
+      pivoted after reading `aisuite`'s actual provider source: its only
+      Google provider is Vertex AI (`GOOGLE_PROJECT_ID`/`GOOGLE_REGION`/a
+      service-account JSON) — no path to a plain Gemini/AI-Studio API key,
+      which is what the existing setup actually used. `litellm` has a
+      separate `gemini` provider (distinct from its own `vertex_ai`) that
+      reads `GEMINI_API_KEY` directly, so the simple-API-key setup carries
+      over unchanged. Added `litellm>=1.98` to `pyproject.toml`; dropped
+      `google-genai` and the `from google import genai` import from
+      `services/ai.py`.
+- [x] Swapped both call sites (`ai_headstart_service`,
+      `ai_natural_language_service`) to
+      `litellm.completion(model=model_name, messages=[...])`, reading
+      `response.choices[0].message.content`.
+      **Scope note:** plain chat completions only, no `tools=`. The model
+      still returns one JSON list of `{command, args, kwargs}` up front,
+      same shape/contract as today, executed through `execute_commands`
+      with no confirmation step — that's deliberate for this pass, not an
+      oversight. The tool-calling loop is 2.4, later, not here. Model
+      strings are `provider/model` (litellm's separator, e.g.
+      `gemini/gemini-3.6-flash`, `openai/gpt-4o-mini`).
+- [x] `litellm` reads provider credentials from standard provider env vars
+      (`OPENAI_API_KEY`, `GEMINI_API_KEY`, etc.), not a key passed in.
+      Dropped the `@config("GEMINI_API_KEY", "api_key")` plumbing entirely —
       one less thing to configure and one less place a secret sits in the
       plaintext user JSON db.
-- [ ] Rename `CLIConfig.GEMINI_MODEL`/`GEMINI_API_KEY` to a single
-      `AI_MODEL` field holding the `provider:model` string.
-
-### 2.3 — Update setup script for `aisuite`
-
-- [ ] `services/user_setup.py`: replace `_get_gemini_api_key` /
-      `_select_gemini_model` with a single prompt for `AI_MODEL`
-      (`provider:model`), plus a printed reminder to set the matching
-      provider env var (e.g. "set `OPENAI_API_KEY` in your environment")
-      rather than storing a key in the db.
-- [ ] Update `help_menu.py` / README wherever `GEMINI_API_KEY`/
-      `GEMINI_MODEL` are referenced (`task config set GEMINI_API_KEY ...`
-      example in the README) to match the new config shape.
+- [x] Renamed `CLIConfig.GEMINI_MODEL`/`GEMINI_API_KEY` to a single
+      `AI_MODEL` field holding the `provider/model` string.
+- [x] Kept printing the parsed command list before executing it
+      (`print(response_json)`) — cheap safety net given the parsed commands
+      can include `delete`/`nuke`. Still just visibility, not a confirmation
+      prompt — real gating is what 2.4 adds.
+
+### 2.2 — Context injection (`--context`), including the multi-file kink
+
+- [x] `--context <path1,path2,...>` on `task ai <prompt>`: comma-separated
+      as planned (sidesteps the `_parse_remaining` repeated-flag kink
+      entirely — never needed to touch it). `_read_context_files()` in
+      `services/ai.py` reads each file and folds them into the prompt as
+      `--- <path> ---\n<contents>` sections, inserted between the item tree
+      and the user's actual prompt.
+- [x] Real landmine found while wiring this up, not in the original plan:
+      `execute_commands`'s `case "ai":` dispatch built the prompt string
+      from `args[1:]` but never forwarded `**kwargs` to
+      `Controller.ai_natural_language` at all — any `--flag` on `task ai
+      ...` was silently parsed and then dropped on the floor before
+      `--context` even had a chance to matter. Fixed by forwarding
+      `**kwargs` through the `case "ai":` dispatch and having
+      `Controller.ai_natural_language` (`cli.py`) and
+      `ai_natural_language_service` (`services/ai.py`) both accept it
+      explicitly. A missing/misspelled path just raises `FileNotFoundError`
+      naturally, caught by `execute_commands`'s existing catch-all — no new
+      error handling needed.
+- [x] Documented `--context` (and `--reasoning`, below) under `task ai` in
+      `help_menu.py`, which is also the AI's own command reference — this
+      command doesn't affect what the LLM is allowed to emit (it's a
+      human-only flag on the `ai` invocation itself, not a command the
+      model generates), but the doc was out of sync with reality otherwise.
+
+**Also added, not originally scoped:** `--reasoning <level>` on `task ai
+<prompt>`, passed straight through as `reasoning_effort` on the
+`litellm.completion(...)` call — came out of a discussion about `task ai`
+latency. Accepted values (`minimal|low|medium|high|disable|none`) aren't
+validated client-side; an invalid value raises litellm's own
+`Invalid reasoning effort: <value>` error, which already surfaces cleanly
+through the same catch-all. No default is set — omitting the flag means no
+`reasoning_effort` is sent at all, so behavior is whatever the model/provider
+defaults to. (A `"disable"` default was tried and explicitly reverted this
+session — worth knowing if it comes up again.) Confirmed by reading
+litellm's Gemini transformation source directly: on Gemini 2.5-series models
+this maps to a `thinkingBudget` token count and `"none"` genuinely zeroes
+it out, but on Gemini 3.x (the default in `llm_models.py`'s menu) it maps
+to a `thinkingLevel` enum and litellm's own code comment states Gemini 3
+*cannot* fully disable thinking — `"disable"`/`"none"` just fall back to
+the minimum level. Also gated behind `supports_reasoning(model, ...)`
+internally, so it's silently a no-op (or may error) on non-reasoning tiers
+like Flash-Lite.
+
+### 2.3 — Update setup script for `litellm`
+
+- [x] `services/user_setup.py` reworked into a two-step picker: select a
+      provider, then select a model, both via a numbered-menu-or-free-text
+      prompt (`_select_from_list`) — typing a number picks from the menu,
+      typing anything else is taken literally, so a stale/missing menu entry
+      never blocks you. Combines to `AI_MODEL = "<provider>/<model>"` and
+      prints the exact env var(s) that provider needs.
+- [x] New [taskai/llm_models.py](taskai/llm_models.py) (top-level, not
+      under `services/`, since it's reference data, not a service):
+      `PROVIDER_ENV_VARS` and `PROVIDER_MODELS`, both keyed by litellm's
+      real provider names, pulled from `litellm.types.utils.LlmProviders`
+      and `litellm.utils.validate_environment` directly rather than
+      guessed. `PROVIDER_MODELS` is a non-exhaustive, best-effort menu —
+      model names go stale fast, confirmed live mid-session: the `gemini`
+      entries needed a web-search correction after `gemini-2.0-flash`
+      turned out to have been shut down 2026-06-01 and `gemini-3.6-flash`
+      didn't exist yet in training data. Re-verify against
+      https://ai.google.dev/gemini-api/docs/models if `task setup`'s Gemini
+      options look off again.
+- [x] Updated README's Config section to match the new `AI_MODEL`
+      `provider/model` shape and point at `task setup`.
+
+### 2.4 — `task ai agent <prompt>` (later — real tool-calling loop)
+
+A separate entry point, not a replacement for `task ai`. `task ai <prompt>`
+stays the fast, ungated, one-shot-plan-and-execute path from 2.1-2.3;
+`task ai agent <prompt>` is for workflows where the model actually needs to
+see intermediate results (e.g. the real id of an item it just created)
+before deciding the next step, which a one-shot plan can't do.
+
+**Note (post-litellm-pivot):** this section was originally scoped around
+`aisuite`'s automatic tool-runner (`tools=[...]` + `max_turns`, which drives
+the call → execute → feed-result-back loop for you). `litellm.completion`
+also accepts `tools=[...]` (OpenAI-style function-calling schema) but has no
+automatic multi-turn runner — the loop below would need to be hand-rolled.
+Re-scope this section before starting 2.4.
+
+- [ ] Small, explicitly-typed wrapper functions — one per meaningful
+      command (create, update, complete, delete, comment, depend, link,
+      move; roughly 8-12 total, not one-per-every-CLI-verb) — calling
+      straight into the existing `Controller` methods, exposed as
+      `tools=[...]` to `litellm.completion`.
+- [ ] Hand-roll the call → execute → feed-result-back loop (no automatic
+      runner in `litellm`, unlike the originally-planned `aisuite`), capped
+      at some max number of turns.
+- [ ] Gate destructive tools (`delete`, `nuke`) behind an explicit yes/no
+      confirmation before executing — not just the print-before-execute
+      visibility 2.1 has.
+- [ ] Print/log the tool-call transcript as it runs so the agent shows its
+      work — same spirit as 2.1's visibility bullet, scaled to a multi-step
+      run.
+- [ ] Flagged, not scoped yet: multi-turn memory across calls in one
+      session, a per-call `--model` override, streaming for plain-text
+      responses (`headstart`). Revisit after 2.4 ships if still wanted.
 
 ---
 

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.5
 Name: taskai-cli
-Version: 1.5.4
+Version: 1.6.2
 Author-email: Alex Paskal <alexcpaskal@gmail.com>
 Requires-Python: >=3.12
 Requires-Dist: fastapi>=0.141.1
-Requires-Dist: google-genai>=2.8
+Requires-Dist: litellm>=1.98
 Requires-Dist: orjson>=3.11
 Requires-Dist: pydantic>=2.13
 Requires-Dist: rich>=15
@@ -84,11 +84,12 @@ Pass any of these as `--field value` to `create`, `add`, or `update`:
 
 ## Config
 
-AI features require a Gemini API key:
+AI features require a model, set as a `provider/model` string (via [litellm](https://github.com/BerriAI/litellm)),
+plus that provider's credentials set as environment variables (e.g. `GEMINI_API_KEY`, `OPENAI_API_KEY`).
+`task setup` will walk you through picking a provider and model and tell you which env vars it needs.
 
 ```bash
-task config set GEMINI_API_KEY <your-key>
-task config set GEMINI_MODEL gemini-2.0-flash
+task config set AI_MODEL gemini/gemini-2.0-flash
 ```
 
 ---

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/README.md

@@ -71,11 +71,12 @@ Pass any of these as `--field value` to `create`, `add`, or `update`:
 
 ## Config
 
-AI features require a Gemini API key:
+AI features require a model, set as a `provider/model` string (via [litellm](https://github.com/BerriAI/litellm)),
+plus that provider's credentials set as environment variables (e.g. `GEMINI_API_KEY`, `OPENAI_API_KEY`).
+`task setup` will walk you through picking a provider and model and tell you which env vars it needs.
 
 ```bash
-task config set GEMINI_API_KEY <your-key>
-task config set GEMINI_MODEL gemini-2.0-flash
+task config set AI_MODEL gemini/gemini-2.0-flash
 ```
 
 ---

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskai-cli"
-version = "1.5.4"
+version = "1.6.2"
 description = ""
 authors = [{name = "Alex Paskal", email = "alexcpaskal@gmail.com"}]
 readme = "README.md"
@@ -9,7 +9,7 @@ dependencies = [
     "pydantic>=2.13",
     "rich>=15",
     "orjson>=3.11",
-    "google-genai>=2.8",
+    "litellm>=1.98",
     "fastapi>=0.141.1",
     "uvicorn>=0.52.3",
 ]

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/taskai/cli.py

@@ -179,8 +179,12 @@ class Controller:
         Controller.create_comment(item.id, comment_content)
         print(comment_content)
 
-    def ai_natural_language(prompt: str):
-        ai_natural_language_service(db, prompt)
+    def ai_natural_language(prompt: str, **kwargs):
+        ai_natural_language_service(
+            db, prompt,
+            context=kwargs.get("context"),
+            reasoning=kwargs.get("reasoning"),
+        )
     
     def throw_error(error_description: str, *args, **kwargs):
         print(f"[red]ERROR: {error_description}[/red]\nargs={args}\nkwargs={kwargs}")
@@ -272,7 +276,7 @@ class Controller:
         db.commit()
 
     def browser_service():
-        subprocess.run(['uvicorn','taskai.browser:app','--reload'])
+        subprocess.run([sys.executable, '-m', 'uvicorn', 'taskai.browser:app', '--reload'])
         
 
 
@@ -399,7 +403,7 @@ def execute_commands(*args, **kwargs) -> int:
             case "ai":
                 match args[1]:
                     case "headstart": Controller.ai_headstart(*args[2:], **kwargs)
-                    case _: Controller.ai_natural_language(" ".join(args[1:]))
+                    case _: Controller.ai_natural_language(" ".join(args[1:]), **kwargs)
 
             case "nuke":
                 db.remove()

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/taskai/help_menu.py

@@ -47,6 +47,8 @@ Item fields (pass as '--field value' to create/add/update):
 
 AI:
 'task ai {prompt}' --> feed a prompt to an LLM, which converts it into a series of the commands above and runs them
+  --context {path[,path...]}  fold the contents of one or more files into the prompt as extra context
+  --reasoning {level}         how hard the model should think before answering: minimal|low|medium|high|disable|none
 'task ai headstart {id}' --> ask an LLM to suggest the next concrete step for an item; the answer is saved as a comment
 
 Config:

taskai_cli-1.6.2/taskai/llm_models.py

@@ -0,0 +1,57 @@
+"""
+Reference data for AI setup: known providers, the env vars litellm reads for
+each, and a best-effort (non-exhaustive) list of models per provider.
+
+Model names go stale fast - this is a helpful menu, not a hard whitelist.
+Provider keys match litellm's `provider/model` naming convention exactly
+(see litellm.types.utils.LlmProviders) - keep in sync if that changes.
+"""
+
+# env vars litellm reads per provider
+PROVIDER_ENV_VARS = {
+    "openai": ["OPENAI_API_KEY"],
+    "anthropic": ["ANTHROPIC_API_KEY"],
+    "gemini": ["GEMINI_API_KEY"],
+    "vertex_ai": ["VERTEXAI_PROJECT", "VERTEXAI_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"],
+    "groq": ["GROQ_API_KEY"],
+    "mistral": ["MISTRAL_API_KEY"],
+    "together_ai": ["TOGETHERAI_API_KEY"],
+    "xai": ["XAI_API_KEY"],
+    "deepseek": ["DEEPSEEK_API_KEY"],
+    "cohere": ["COHERE_API_KEY"],
+    "fireworks_ai": ["FIREWORKS_AI_API_KEY"],
+    "nebius": ["NEBIUS_API_KEY"],
+    "sambanova": ["SAMBANOVA_API_KEY"],
+    "huggingface": ["HUGGINGFACE_API_KEY"],
+    "azure": ["AZURE_API_KEY", "AZURE_API_VERSION", "AZURE_API_BASE"],
+    "bedrock": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"],
+    "watsonx": ["WATSONX_API_KEY", "WATSONX_PROJECT_ID", "WATSONX_URL"],
+    "cerebras": ["CEREBRAS_API_KEY"],
+    "inception": ["INCEPTION_API_KEY"],
+    "ollama": ["OLLAMA_API_BASE"],
+}
+
+# example/known models per provider - not exhaustive, just a menu to pick from
+# or type past (e.g. a newer model the provider has added since this was written)
+PROVIDER_MODELS = {
+    "openai": ["gpt-5", "gpt-4o", "gpt-4o-mini", "o3", "o3-mini"],
+    "anthropic": ["claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5-20251001", "claude-fable-5"],
+    "gemini": ["gemini-3.7-flash", "gemini-3.1-pro-preview", "gemini-3.6-flash", "gemini-3.5-flash-lite", "gemini-2.5-pro"],
+    "vertex_ai": ["gemini-3.7-flash", "gemini-3.1-pro-preview", "gemini-3.6-flash", "gemini-2.5-pro"],
+    "groq": ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768", "gemma2-9b-it"],
+    "mistral": ["mistral-large-latest", "mistral-small-latest", "codestral-latest", "pixtral-large-latest"],
+    "together_ai": ["meta-llama/Llama-3.3-70B-Instruct-Turbo", "Qwen/Qwen2.5-72B-Instruct-Turbo", "deepseek-ai/DeepSeek-V3"],
+    "xai": ["grok-4", "grok-4-fast", "grok-3", "grok-3-mini"],
+    "deepseek": ["deepseek-chat", "deepseek-reasoner"],
+    "cohere": ["command-a", "command-r-plus", "command-r"],
+    "fireworks_ai": ["accounts/fireworks/models/llama-v3p3-70b-instruct", "accounts/fireworks/models/deepseek-v3"],
+    "nebius": ["meta-llama/Llama-3.3-70B-Instruct", "Qwen/Qwen2.5-72B-Instruct"],
+    "sambanova": ["Meta-Llama-3.3-70B-Instruct", "Meta-Llama-3.1-8B-Instruct"],
+    "huggingface": ["meta-llama/Llama-3.3-70B-Instruct", "mistralai/Mixtral-8x7B-Instruct-v0.1"],
+    "azure": [],  # model choice is your own Azure deployment name, not a fixed list
+    "bedrock": ["anthropic.claude-3-5-sonnet-20241022-v2:0", "meta.llama3-1-70b-instruct-v1:0", "amazon.titan-text-premier-v1:0"],
+    "watsonx": ["ibm/granite-3-8b-instruct", "meta-llama/llama-3-3-70b-instruct"],
+    "cerebras": ["llama-3.3-70b", "llama3.1-8b"],
+    "inception": ["mercury-coder-small"],
+    "ollama": [],  # whatever model you've pulled locally, e.g. "llama3"
+}

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/taskai/models.py

@@ -64,9 +64,8 @@ class Comment(Base):
 
 class CLIConfig(Base):
 
-    # GEMINI
-    GEMINI_MODEL: str = None
-    GEMINI_API_KEY: str = None
+    # AI
+    AI_MODEL: str = None
 
     # VIEW
     DISPLAY_STRING: str = "id name status due_by"

{taskai_cli-1.5.4 → taskai_cli-1.6.2}/taskai/services/ai.py

@@ -12,12 +12,10 @@ from taskai.models import TodoItem, Comment
 from taskai.config import config
 from taskai.help_menu import help_general
 
-@config("GEMINI_API_KEY", "api_key")
-@config("GEMINI_MODEL", "model_name")
+@config("AI_MODEL", "model_name")
 def ai_headstart_service(
         db: JsonDirectoryDatabase,
         item_id: str,
-        api_key: str,
         model_name: str
 ):
     """
@@ -32,10 +30,7 @@ def ai_headstart_service(
 
     item:TodoItem = db.get_item(item_id)
 
-    
-    from google import genai
-    
-
+    import litellm
 
     # contruct prompt
     prompt = f"""
@@ -69,29 +64,35 @@ task name: {item.name}
             comment: Comment = db.get_comment(comment_id)
             prompt += f"\n\t- {comment.content}"
     # query model
-    client = genai.Client(api_key=api_key)
-    response = client.models.generate_content(
+    response = litellm.completion(
         model=model_name,
-        contents=prompt
+        messages=[{"role": "user", "content": prompt}],
     )
 
-    return response.text
+    return response.choices[0].message.content
+
+def _read_context_files(context: str) -> str:
+    """context is a comma-separated list of file paths"""
+    sections = []
+    for path in context.split(","):
+        path = path.strip()
+        with open(path) as f:
+            sections.append(f"--- {path} ---\n{f.read()}")
+    return "\n\n".join(sections)
 
-@config("GEMINI_API_KEY", "api_key")
-@config("GEMINI_MODEL", "model_name")
+@config("AI_MODEL", "model_name")
 def ai_natural_language_service(
     db: JsonDirectoryDatabase,
     prompt: str,
-    api_key: str,
-    model_name: str
+    model_name: str,
+    context: str = None,
+    reasoning: str = None
 ):
     """
     This service queries an LLM with a natural language
     prompt from the user. The response is a series of terminal commands
     called directly
     """
-    print(f"Ai prompt: {prompt}")
-    
     # recursively build user info
     user_info = []
     _visited_set = set()
@@ -112,6 +113,14 @@ def ai_natural_language_service(
 
     user_info = "\n".join(user_info)
 
+    context_block = ""
+    if context:
+        context_block = f"""
+Here is additional context the user has provided:
+
+{_read_context_files(context)}
+"""
+
     # build ai prompt
     ai_prompt = f"""
 You are a todo agent. Your job is to convert a natural language description from a user into a set
@@ -122,7 +131,7 @@ of CLI operations using our app. Here are a comprehensive list of operations tha
 Here are all of the user's existing item names, each prepended with their id
 
 {user_info}
-
+{context_block}
 Here is the user's prompt:
 
 {prompt}
@@ -178,34 +187,48 @@ markdown formatting. Just the raw json string.
 
 """
 
-    
-    from google import genai
+    import litellm
+
+    completion_kwargs = {}
+    if reasoning:
+        completion_kwargs["reasoning_effort"] = reasoning
 
-    print(ai_prompt)
-    client = genai.Client(api_key=api_key)
-    response = client.models.generate_content(
+    response = litellm.completion(
         model=model_name,
-        contents=ai_prompt
+        messages=[{"role": "user", "content": ai_prompt}],
+        **completion_kwargs,
     )
+    response_text = response.choices[0].message.content
 
     try:
-        response_json = json.loads(response.text)
+        response_json = json.loads(response_text)
     except json.JSONDecodeError:
-        print(response.text)
+        print(response_text)
         print("\n\ndecode error")
         import sys
         sys.exit(-1)
 
-    print(response_json)
-
     from taskai.cli import execute_commands
 
     for entry in response_json:
         command = entry["command"]
         cmd_args = entry.get("args", [])
+        raw_kwargs = entry.get("kwargs", {})
         cmd_kwargs = {
             k.lstrip("-"): v
-            for k, v in entry.get("kwargs", {}).items()
+            for k, v in raw_kwargs.items()
         }
+        print(f"ai run '{_format_command_str(command, cmd_args, raw_kwargs)}'")
         execute_commands(command, *cmd_args, **cmd_kwargs)
 
+def _format_command_str(command: str, args: list, kwargs: dict) -> str:
+    def quote(value):
+        value = str(value)
+        return f"'{value}'" if " " in value else value
+
+    parts = ["task", command] + [quote(a) for a in args]
+    for k, v in kwargs.items():
+        key = k if k.startswith("--") else f"--{k}"
+        parts.append(f"{key} {quote(v)}")
+    return " ".join(parts)
+

taskai_cli-1.6.2/taskai/services/user_setup.py

@@ -0,0 +1,75 @@
+"""
+This service will handle user setup and configuration
+
+Basically, we're going to have a set of steps that we're going to iterate through
+"""
+from taskai.json_dir_database import JsonDirectoryDatabase
+from taskai.llm_models import PROVIDER_ENV_VARS, PROVIDER_MODELS
+
+from rich.prompt import Prompt
+from rich import print
+
+
+def user_setup_service(
+    db: JsonDirectoryDatabase
+):
+
+    config = db.get_config()
+    # setup ai model
+    print("Beginning setup")
+    if "AI_MODEL" not in config:
+        model = _get_ai_model()
+        if model:
+            db.update_config(AI_MODEL=model)
+    else:
+        print("AI model already specified")
+    print("Setup complete! Use 'task config set|get|list' to interact with your configuration options")
+    db.commit()
+
+def _select_from_list(prompt_text: str, options: list[str]) -> str:
+    """Show a numbered menu of options; accept either a number or free text."""
+    if options:
+        print("\n".join(f"  {i}. {opt}" for i, opt in enumerate(options, 1)))
+    response = Prompt.ask(prompt_text)
+    if response.isdigit() and 1 <= int(response) <= len(options):
+        return options[int(response) - 1]
+    return response
+
+def _get_ai_model() -> str|None:
+    provider = _select_from_list(
+        "\nSelect a provider (number or name)", list(PROVIDER_ENV_VARS)
+    )
+    if not provider:
+        return
+
+    model_options = PROVIDER_MODELS.get(provider, [])
+    model = _select_from_list(
+        f"\nSelect a model for '{provider}' (number or name)", model_options
+    )
+    if not model:
+        return
+
+    response = f"{provider}/{model}"
+    print(f"Storing: [green]{response}[/green]")
+
+    env_vars = PROVIDER_ENV_VARS.get(provider)
+    if env_vars is None:
+        print(
+            f"Unrecognized provider '{provider}' - check litellm's docs for the "
+            f"env var(s) it expects, and add it to PROVIDER_ENV_VARS in "
+            f"llm_models.py if you use it regularly."
+        )
+    elif env_vars:
+        print("Make sure these environment variables are set:\n" + "\n".join(f"  {v}" for v in env_vars))
+    else:
+        print(f"'{provider}' runs locally - no credentials needed.")
+    return response
+
+
+if __name__ == "__main__":
+    import os
+    db = JsonDirectoryDatabase(
+        ".taskai/task_db", user=os.getenv("USER")
+    )
+    db.connect()
+    user_setup_service(db)

taskai_cli-1.5.4/taskai/services/user_setup.py

@@ -1,63 +0,0 @@
-"""
-This service will handle user setup and configuration
-
-Basically, we're going to have a set of steps that we're going to iterate through
-"""
-from taskai.json_dir_database import JsonDirectoryDatabase
-
-from rich.prompt import Prompt
-from rich import print
-import os
-
-
-def user_setup_service(
-    db: JsonDirectoryDatabase
-):
-    
-    config = db.get_config()
-    # setup gemini model
-    print("Beginning setup")
-    if "GEMINI_API_KEY" not in config:
-        api_key = _get_gemini_api_key()
-        if api_key:
-            db.update_config(GEMINI_API_KEY=api_key)
-    else:
-        print("gemini key already specified")
-    
-    if "GEMINI_MODEL" not in config:
-        model = _select_gemini_model()
-        if model:
-            db.update_config(GEMINI_MODEL=model)
-    else:
-        print("gemini model already specified")
-    print("Setup complete! Use 'task config set|get|list' to interact with your configuration options")
-    db.commit()
-
-def _get_gemini_api_key() -> str|None:
-    response = Prompt.ask("Please enter your Gemini API key (use '$--' to access env vars)")
-    
-    if response.startswith("$"):
-        response = os.getenv(response[1:])
-    if not response:
-        return
-    print(f"Storing: [green]{response}[/green]")
-    return response
-
-
-def _select_gemini_model():
-    response = Prompt.ask(
-        "Please select which Gemini model you would like:",
-        choices=[
-            "gemini-3.5-flash"
-        ]
-    )
-    return response
-
-
-if __name__ == "__main__":
-    import os
-    db = JsonDirectoryDatabase(
-        ".taskai/task_db", user=os.getenv("USER")
-    )
-    db.connect()
-    user_setup_service(db)