claude-dev-kit 2.1.0

package/.claude/commands/ai/detect.md

@@ -0,0 +1,117 @@
+---
+description: "Detect which AI CLI tools are installed and update providers.json with availability status."
+argument-hint: []
+---
+
+# /ai:detect — AI Provider Detection
+
+Scan the system for installed AI CLI tools, update `.claude/providers.json` with current availability, and report what's ready to use.
+
+## Steps
+
+### 1. Read current providers.json
+
+```bash
+cat .claude/providers.json
+```
+
+Extract the list of providers and their `cli` fields.
+
+### 2. Check each CLI's availability
+
+Run these checks **in parallel**:
+
+```bash
+# Claude (always available inside Claude Code — check for standalone CLI too)
+which claude 2>/dev/null && claude --version 2>/dev/null | head -1 || echo "NOT_FOUND"
+
+# Gemini
+which gemini 2>/dev/null && gemini --version 2>/dev/null | head -1 || echo "NOT_FOUND"
+
+# OpenCode (covers Codex, Grok, Kimi via --model flag)
+which opencode 2>/dev/null && opencode --version 2>/dev/null | head -1 || echo "NOT_FOUND"
+
+# Ollama (local LLMs)
+which ollama 2>/dev/null && ollama --version 2>/dev/null | head -1 || echo "NOT_FOUND"
+
+# GLM wrapper
+which cczy 2>/dev/null || echo "NOT_FOUND"
+
+# MiniMax wrapper
+which ccmy 2>/dev/null || echo "NOT_FOUND"
+```
+
+### 2b. If Ollama is found, list available models
+
+```bash
+ollama list 2>/dev/null | tail -n +2 | awk '{print $1}'
+```
+
+Use this list to:
+- Confirm Ollama is running (if the command fails with a connection error, set a warning that `ollama serve` may not be running)
+- Set the `model` field in providers.json to the first available coding model found, using this preference order: `qwen2.5-coder`, `codellama`, `deepseek-coder-v2`, `llama3.2`, `llama3.1`, `mistral`, `gemma3` — or the first model in the list if none match
+
+### 3. Build detection results
+
+For each provider, mark:
+- `"available": true` — CLI found and responds
+- `"available": false` — CLI not found
+- Note: `opencode` covers codex, grok, kimi, and opencode providers
+
+Special rules:
+- `claude`: always `true` (we are running inside Claude Code)
+- `codex`, `grok`, `kimi`: set to `true` if `opencode` is available
+- `glm`: set to `true` if `cczy` is available
+- `minimax`: set to `true` if `ccmy` is available
+- `ollama`: set to `true` if `ollama` binary found AND at least one model is installed; also update the `model` field with the best available model (see step 2b)
+
+### 4. Update providers.json
+
+Read the current providers.json and update each provider's `"available"` field with the detection results.
+
+Write the updated JSON back to `.claude/providers.json`.
+
+### 5. Report results
+
+Print a table:
+
+```
+## AI Provider Detection Results
+
+| Provider    | CLI        | Available | Strengths                         |
+|-------------|------------|-----------|-----------------------------------|
+| claude      | claude     | ✓         | reasoning, agents, coding         |
+| gemini      | gemini     | ✓ / ✗     | large-context, web-search         |
+| codex       | opencode   | ✓ / ✗     | coding, code-completion           |
+| grok        | opencode   | ✓ / ✗     | speed, reasoning                  |
+| kimi        | opencode   | ✓ / ✗     | coding, math                      |
+| ollama      | ollama     | ✓ / ✗     | privacy, offline, no-cost [LOCAL] |
+| glm         | cczy       | ✓ / ✗     | multilingual                      |
+| minimax     | ccmy       | ✓ / ✗     | multimodal                        |
+| opencode    | opencode   | ✓ / ✗     | coding, multi-model               |
+
+## Ollama Models Installed
+<list from `ollama list`, or "none" if not installed>
+Active model: <value of providers.ollama.model>
+
+## Current Default: <value of "default" field>
+
+## Routing Configuration
+Large context tasks → <routing.large_context>
+Speed tasks → <routing.speed>
+Coding tasks → <routing.coding>
+Privacy/offline tasks → ollama (if available)
+
+## Tips
+- Install Gemini CLI: https://github.com/google-gemini/gemini-cli
+- Install OpenCode: https://opencode.ai/docs/installation
+- Install Ollama (local LLMs): https://ollama.ai — then run `ollama pull llama3.2`
+- Switch Ollama model: /ai:switch ollama:codellama
+- Run /ai:switch <provider> to change the default provider
+```
+
+## Notes
+
+- This command is safe to re-run at any time
+- providers.json is updated in-place with only the `available` fields changed
+- Other fields (run_cmd, strengths, notes) are preserved exactly

package/.claude/commands/ai/route.md

@@ -0,0 +1,128 @@
+---
+description: "Route a task to the best available AI CLI tool based on task type. Claude orchestrates and returns the result."
+argument-hint: [task description]
+---
+
+# /ai:route — Intelligent AI Task Routing
+
+Analyze the task, select the optimal AI provider based on available CLIs and task type, execute the task, and return the result. Claude Code always orchestrates — it calls the chosen AI as a subprocess and synthesizes the response.
+
+## Steps
+
+### 1. Get the task
+
+```
+TASK = $ARGUMENTS
+```
+
+If empty, ask the user: "What task do you want to route to the best AI? Describe the task."
+
+### 2. Read providers configuration
+
+```bash
+cat .claude/providers.json
+```
+
+Identify:
+- `routing` preferences object
+- Which providers have `"available": true`
+
+### 3. Determine task type and select provider
+
+Analyze `TASK` against these patterns:
+
+**Large context / full codebase:**
+- Keywords: "entire codebase", "all files", "full project scan", "whole repo", "scan everything"
+- → Use `routing.large_context` provider (default: gemini)
+
+**Speed-first:**
+- Keywords: "quick", "fast", "briefly", "tldr", "one sentence", "just tell me"
+- → Use `routing.speed` provider (default: grok)
+
+**Code generation / implementation:**
+- Keywords: "implement", "write a function", "create a class", "code that", "build a"
+- → Use `routing.coding` provider (default: claude)
+
+**Multi-AI synthesis:**
+- Keywords: "brainstorm", "multiple perspectives", "compare approaches", "what do different AIs think"
+- → Suggest `/bs:brainstorm_full` instead
+
+**Math / algorithms:**
+- Keywords: "algorithm", "complexity", "O(n)", "optimize", "calculate", "math"
+- → Use kimi if available, otherwise claude
+
+**Privacy / local / sensitive:**
+- Keywords: "private", "don't send to cloud", "local only", "confidential", "sensitive data", "air-gapped", "offline", "no cloud"
+- → Use ollama if available (data stays on machine), otherwise warn the user and use claude
+
+**Default:** Use the `"default"` provider from providers.json.
+
+If selected provider is unavailable, fall back to claude.
+
+### 4. Show routing decision
+
+```
+Routing to: <provider_name> (<reason>)
+Context window: <context_window> tokens
+```
+
+### 5. Execute with selected provider
+
+Read `run_cmd` from providers.json for the selected provider.
+Substitute template variables in `run_cmd`:
+- Replace `{prompt}` with the properly shell-escaped task content
+- Replace `{model}` with the value of `providers.<name>.model` (used by Ollama)
+
+**For type: cli:**
+```bash
+<run_cmd with {prompt} and {model} substituted>
+```
+
+**For type: piped:**
+```bash
+echo '<escaped_task>' | <run_cmd with {prompt} removed>
+```
+(The piped CLI reads the prompt from stdin)
+
+**For Ollama specifically:** Before running, verify the Ollama service is reachable:
+```bash
+ollama list 2>/dev/null | head -1 || echo "OLLAMA_DOWN"
+```
+If `OLLAMA_DOWN`, inform the user: "Ollama is installed but not running. Start it with: `ollama serve`"
+
+Run in background if long-running:
+- `run_in_background: true` for tasks that may take > 30 seconds
+
+Wait for completion (no timeout — let it run as long as needed).
+
+### 6. Return result
+
+```
+## Result from <provider_name>
+
+<output>
+
+---
+Routed by: ai-router | Provider: <provider_name> | Task type: <detected_type>
+```
+
+### 7. Optionally compare
+
+If the user's task looks like it would benefit from comparison (e.g., architecture decisions, complex tradeoffs), after returning the primary result ask:
+
+> "Want me to also get a second opinion from [another available provider]?"
+
+## Error Handling
+
+If the selected provider fails (exit non-zero):
+1. Report the error clearly
+2. Automatically fall back to claude
+3. Re-run the task with claude
+4. Note which provider failed
+
+## Notes
+
+- Claude Code is always the orchestrator — it never "becomes" another AI
+- Other AIs are called as subprocess CLIs and their output is returned here
+- Sensitive data (API keys, .env contents) should never be included in the task prompt sent to external providers
+- The routing configuration in providers.json can be customized with `/ai:switch`

package/.claude/commands/ai/switch.md

@@ -0,0 +1,121 @@
+---
+description: "Switch the default AI provider used for tasks. Run /ai:detect first to see available providers. Use 'ollama:<model>' to change the active Ollama model."
+argument-hint: [claude | gemini | codex | grok | kimi | ollama | ollama:<model> | glm | minimax | opencode]
+---
+
+# /ai:switch — Switch Default AI Provider
+
+Change which AI CLI tool is used as the default for tasks. This updates the `"default"` field in `.claude/providers.json`.
+
+## Steps
+
+### 1. Parse the requested provider
+
+```
+REQUESTED = $ARGUMENTS (trimmed, lowercased)
+```
+
+If `$ARGUMENTS` is empty, skip to the listing step below.
+
+**Special case — Ollama model switch:**
+If `REQUESTED` starts with `ollama:` (e.g. `ollama:codellama`):
+- Extract the model name after the colon: `MODEL = everything after "ollama:"`
+- Read providers.json
+- Verify `ollama` provider exists
+- Update `providers.ollama.model` to `MODEL`
+- Write updated providers.json
+- Report: `Ollama model set to: <MODEL>` and stop
+
+### 2. Read providers.json
+
+```bash
+cat .claude/providers.json
+```
+
+### 3. Validate the requested provider
+
+Check that `REQUESTED` is a key in the `providers` object.
+
+If not found:
+```
+Unknown provider: "<REQUESTED>"
+
+Available providers:
+  claude, gemini, codex, grok, kimi, ollama, glm, minimax, opencode
+
+For Ollama, you can also set the active model:
+  /ai:switch ollama:codellama
+  /ai:switch ollama:qwen2.5-coder
+  /ai:switch ollama:deepseek-coder-v2
+
+Run /ai:detect to check which are installed and list Ollama models.
+```
+Stop.
+
+### 4. Check availability
+
+If `providers[REQUESTED].available` is `false`:
+```
+Warning: <REQUESTED> is not currently available (CLI not detected).
+Run /ai:detect to refresh availability, or install the CLI first.
+
+Continue anyway? (Note: tasks will fail at runtime if the CLI is missing.)
+```
+
+Ask the user with AskUserQuestion whether to proceed despite unavailability.
+
+If user says no, stop.
+
+### 5. Update providers.json
+
+Set `"default": "<REQUESTED>"` in providers.json.
+
+Write the updated JSON back.
+
+### 6. Report success
+
+```
+## Default AI switched to: <provider_name>
+
+Provider: <name>
+CLI: <cli>
+Strengths: <strengths list>
+Context Window: <context_window> tokens
+
+The routing configuration still applies:
+  Large context → <routing.large_context>
+  Speed → <routing.speed>
+  Coding → <routing.coding>
+
+Run /ai:route <task> to intelligently route a specific task.
+Run /ai:detect to refresh which providers are available.
+```
+
+---
+
+## If $ARGUMENTS is empty — show current state
+
+```
+## Current AI Configuration
+
+Default provider: <default>
+
+All providers:
+  ✓ claude    — reasoning, agents, coding        [always available]
+  ✓/✗ gemini  — large-context, web-search        [installed / not installed]
+  ✓/✗ codex   — coding, code-completion          [requires opencode]
+  ✓/✗ grok    — speed, reasoning                 [requires opencode]
+  ✓/✗ kimi    — coding, math                     [requires opencode]
+  ✓/✗ ollama  — privacy, offline, no-cost [LOCAL] [requires ollama]
+  ✓/✗ glm     — multilingual                     [requires cczy]
+  ✓/✗ minimax — multimodal                       [requires ccmy]
+  ✓/✗ opencode — coding, multi-model             [requires opencode]
+
+Usage:
+  /ai:switch gemini           — use Gemini as default
+  /ai:switch ollama           — use Ollama (local) as default
+  /ai:switch ollama:codellama — switch to codellama model in Ollama
+  /ai:switch claude           — revert to Claude
+  /ai:detect                  — refresh availability + list Ollama models
+  /ai:route <task>            — route specific task to best AI
+```

package/.claude/commands/bs/brainstorm_full.md

@@ -0,0 +1,149 @@
+---
+description: Brainstorm using 7 different LLMs (four-step flow)
+---
+
+# Multi-LLM Brainstorming (Mode)
+
+You are orchestrating a multi-LLM brainstorming workflow using background tasks and explicit output retrieval.
+
+This workflow has four phases:
+
+- Phase 0: Determine the brainstorm prompt
+- Phase 1: Launch 7 LLMs in parallel (background)
+- Phase 2: Collect results
+- Phase 3: Synthesize results
+
+---
+
+## Phase 0 — Get the prompt
+
+1. If `$ARGUMENTS` is **not empty**, then:
+   - Set `PROMPT = $ARGUMENTS`
+   - Skip asking the user anything and go straight to **Phase 1**.
+
+2. If `$ARGUMENTS` is **empty**, then:
+   - Say **only**:
+     > Multi-LLM brainstorm mode activated. Send me your brainstorm question in the next message.
+   - Then **wait** for the user's next message.
+   - When the user replies, set:
+     - `PROMPT =` the full content of that next user message.
+   - Immediately continue with **Phase 1** using `PROMPT`.
+
+---
+
+## Phase 1 — Launch 7 LLMs in parallel
+
+Launch ALL 7 LLMs **in a single message** using background execution.
+Append to `PROMPT`: "Do **not** make any changes in code. Do **not** modify any files."
+
+Let each tool run as long as necessary. Don't enforce any timeouts or finish tasks by timeout.
+**IMPORTANT** - don't stop any process. Let LLM to work as long as necessary, even if it take 24 hours.
+**NEVER** check intermediate bash output of running bashes. Let them FINISH execution as long as necessary.
+
+`PROMPT_ESCAPED` is properly shell-escaped `PROMPT`
+
+**CRITICAL**: Use the actual **Bash** tool, NOT the Skill tool. Launch all 7 in ONE message with these exact tool calls:
+
+1. **Claude**
+   Use **Bash** tool:
+   - `command`: `echo "PROMPT_ESCAPED" | env -u CLAUDECODE claude -p --agent deep-think-partner`
+   - `run_in_background`: `true`
+   - `description`: `Claude brainstorm`
+
+2. **Codex**
+   Use **Bash** tool:
+   - `command`: `opencode run --model openai/gpt-5.3-codex "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Codex brainstorm`
+
+3. **Gemini**
+   Use **Bash** tool:
+   - `command`: `gemini -p "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Gemini brainstorm`
+
+4. **Grok**
+   Use **Bash** tool:
+   - `command`: `opencode run --model openrouter/x-ai/grok-4.1-fast "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Grok brainstorm`
+
+5. **Glm**
+   Use **Bash** tool:
+   - `command`: `echo "PROMPT_ESCAPED" | env -u CLAUDECODE cczy -p --agent deep-think-partner`
+   - `run_in_background`: `true`
+   - `description`: `Glm brainstorm`
+
+6. **MiniMax**
+   Use **Bash** tool:
+   - `command`: `echo "PROMPT_ESCAPED" | env -u CLAUDECODE ccmy -p --agent deep-think-partner`
+   - `run_in_background`: `true`
+   - `description`: `MiniMax brainstorm`
+
+7. **Kimi**
+   Use **Bash** tool:
+   - `command`: `opencode run --model openrouter/moonshotai/kimi-k2.5 "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Kimi brainstorm`
+
+After launching, you will receive task IDs for each background process.
+
+---
+
+## Phase 2 — Collect results and Synthesize
+
+Use **TaskOutput** tool to retrieve each result. Call TaskOutput for each task_id with `block: true` to wait for completion.
+
+**IMPORTANT**: Let each task run as long as needed. Do NOT impose any timeouts.
+
+As each result comes in, display it clearly labeled:
+
+```
+### Claude
+[paste Claude's response here]
+
+### Codex
+[paste Codex's response here]
+
+### Gemini
+[paste Gemini's response here]
+
+### Grok
+[paste Grok's response here]
+
+### Glm
+[paste Glm's response here]
+
+### MiniMax
+[paste MiniMax's response here]
+
+### Kimi
+[paste Kimi's response here]
+```
+
+If any task fails, note which one failed and continue with the remaining ones.
+
+---
+
+## Phase 3 — Synthesize
+
+After all available model responses are collected:
+
+Provide a concise analysis with these sections:
+
+1. **Consensus** – What do at least 4 models broadly agree on?
+2. **Unique Insights** – What valuable, distinct perspective did each model add?
+3. **Contradictions** – Where do they disagree, and what might explain the difference?
+4. **Recommendation** – Your synthesized best approach / action plan.
+
+Keep the synthesis **concise and actionable**.
+
+---
+
+## Behavior Notes
+
+- Do **not** re-ask for the prompt once `PROMPT` is set, unless the user clearly changes the question.
+- Always use **Bash** and **Task** tools directly, NOT the Skill tool for invoking LLMs.
+- Use `run_in_background: true` for all 7 launches, then retrieve with `TaskOutput`.
+- Do **not** make any changes in code. Do **not** modify any files.
+- If the user gives a new message after the synthesis clearly changing the topic, treat that as a request to **rerun the whole workflow** with the new `PROMPT`.

package/.claude/commands/bs/claude.md

@@ -0,0 +1,37 @@
+---
+description: Run claude cli to execute current promt
+---
+
+# Run Claude LLM
+
+Execute the prompt using Claude CLI in background mode.
+
+## Instructions
+
+1. If `$ARGUMENTS` is **empty**, ask the user for their prompt and wait for their response.
+
+2. Set `PROMPT` to `$ARGUMENTS` (or the user's response if arguments were empty).
+
+   `PROMPT_ESCAPED` is properly shell-escaped `PROMPT`.
+
+3. **Launch in background** using **Bash** tool:
+   - `command`: `echo "PROMPT_ESCAPED" | env -u CLAUDECODE claude -p`
+   - `run_in_background`: `true`
+   - `description`: `Claude execution`
+
+4. **Wait for completion** using **TaskOutput** tool:
+   - `task_id`: the task ID returned from step 3
+   - `block`: `true`
+   - Do NOT set any timeout - let it run as long as necessary
+
+5. Display the result clearly:
+   ```
+   ### Claude Response
+   [paste the response here]
+   ```
+
+## Behavior Notes
+
+- Do **not** impose any timeouts. Let the LLM work as long as necessary.
+- Do **not** check intermediate output. Wait for full completion.
+- Do **not** make any code changes or modify files unless the response explicitly requires it and user confirms.

package/.claude/commands/bs/codex.md

@@ -0,0 +1,37 @@
+---
+description: Run codex cli to execute current promt
+---
+
+# Run Codex LLM
+
+Execute the prompt using Codex CLI in background mode.
+
+## Instructions
+
+1. If `$ARGUMENTS` is **empty**, ask the user for their prompt and wait for their response.
+
+2. Set `PROMPT` to `$ARGUMENTS` (or the user's response if arguments were empty).
+
+   `PROMPT_ESCAPED` is properly shell-escaped `PROMPT`.
+
+3. **Launch in background** using **Bash** tool:
+   - `command`: `opencode run --model openai/gpt-5.3-codex "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Codex execution`
+
+4. **Wait for completion** using **TaskOutput** tool:
+   - `task_id`: the task ID returned from step 3
+   - `block`: `true`
+   - Do NOT set any timeout - let it run as long as necessary
+
+5. Display the result clearly:
+   ```
+   ### Codex Response
+   [paste the response here]
+   ```
+
+## Behavior Notes
+
+- Do **not** impose any timeouts. Let the LLM work as long as necessary.
+- Do **not** check intermediate output. Wait for full completion.
+- Do **not** make any code changes or modify files unless the response explicitly requires it and user confirms.

package/.claude/commands/bs/gemini.md

@@ -0,0 +1,37 @@
+---
+description: Run gemini cli to execute current promt
+---
+
+# Run Gemini LLM
+
+Execute the prompt using Gemini CLI in background mode.
+
+## Instructions
+
+1. If `$ARGUMENTS` is **empty**, ask the user for their prompt and wait for their response.
+
+2. Set `PROMPT` to `$ARGUMENTS` (or the user's response if arguments were empty).
+
+   `PROMPT_ESCAPED` is properly shell-escaped `PROMPT`.
+
+3. **Launch in background** using **Bash** tool:
+   - `command`: `gemini -p "PROMPT_ESCAPED"`
+   - `run_in_background`: `true`
+   - `description`: `Gemini execution`
+
+4. **Wait for completion** using **TaskOutput** tool:
+   - `task_id`: the task ID returned from step 3
+   - `block`: `true`
+   - Do NOT set any timeout - let it run as long as necessary
+
+5. Display the result clearly:
+   ```
+   ### Gemini Response
+   [paste the response here]
+   ```
+
+## Behavior Notes
+
+- Do **not** impose any timeouts. Let the LLM work as long as necessary.
+- Do **not** check intermediate output. Wait for full completion.
+- Do **not** make any code changes or modify files unless the response explicitly requires it and user confirms.

package/.claude/commands/bs/glm.md

@@ -0,0 +1,37 @@
+---
+description: Run claude cli with GLM LLM to execute current promt
+---
+
+# Run Claude LLM
+
+Execute the prompt using Claude CLI with GLM LLM in background mode.
+
+## Instructions
+
+1. If `$ARGUMENTS` is **empty**, ask the user for their prompt and wait for their response.
+
+2. Set `PROMPT` to `$ARGUMENTS` (or the user's response if arguments were empty).
+
+   `PROMPT_ESCAPED` is properly shell-escaped `PROMPT`.
+
+3. **Launch in background** using **Bash** tool:
+   - `command`: `echo "PROMPT_ESCAPED" | env -u CLAUDECODE cczy -p`
+   - `run_in_background`: `true`
+   - `description`: `Claude execution`
+
+4. **Wait for completion** using **TaskOutput** tool:
+   - `task_id`: the task ID returned from step 3
+   - `block`: `true`
+   - Do NOT set any timeout - let it run as long as necessary
+
+5. Display the result clearly:
+   ```
+   ### Claude with GLM LLM Response
+   [paste the response here]
+   ```
+
+## Behavior Notes
+
+- Do **not** impose any timeouts. Let the LLM work as long as necessary.
+- Do **not** check intermediate output. Wait for full completion.
+- Do **not** make any code changes or modify files unless the response explicitly requires it and user confirms.