@monoes/monomindcli 1.6.0

package/.claude/commands/monomind-idea.md

@@ -0,0 +1,269 @@
+---
+name: monomind-idea
+description: "Monomind — Research ideas from a prompt, evaluate them, and decompose into subtasks on monotask boards"
+---
+
+If `$ARGUMENTS` is empty, output this and STOP:
+
+> **Usage:** `/monomind:idea <prompt>`
+>
+> Example: `/monomind:idea add real-time collaboration to the editor`
+>
+> This command researches ideas from your prompt, evaluates them with a product manager lens, elaborates promising ones, and decomposes them into actionable subtasks on monotask boards.
+
+Do NOT proceed further if no arguments were provided.
+
+---
+
+## Step 0: Check monotask CLI
+
+Run:
+```bash
+command -v monotask
+```
+
+If `monotask` is NOT found, attempt to install:
+```bash
+command -v cargo && cargo install monotask
+```
+
+If `cargo` is also missing, output this and STOP:
+> monotask requires Rust. Install Rust first:
+> ```bash
+> curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+> source "$HOME/.cargo/env"
+> cargo install monotask
+> ```
+
+Verify monotask is now available before continuing.
+
+---
+
+## Step 1: Gather Project Context
+
+Collect ALL of the following in parallel (skip any that error):
+
+1. **Repo name**: Run `git remote get-url origin`, extract the last path segment, strip `.git`. Fallback: `basename` of the current working directory. Store as `REPO_NAME`.
+
+2. **README**: Read `README.md` (first 200 lines). Skip if missing.
+
+3. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`. Extract name, description, and keywords/tags.
+
+4. **Knowledge graph**: Call `mcp__monobrain__graphify_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
+
+5. **Memory search**: Call `mcp__monobrain__memory_search` with the user's prompt (`$ARGUMENTS`). Use the top 5 results.
+
+Bundle all gathered information into a single `PROJECT_CONTEXT` string for downstream agents.
+
+---
+
+## Step 2: Setup Monotask Space and Idea Board
+
+### Space
+- Run `monotask space list` and check if a space named `$REPO_NAME` already exists.
+- If not, create it: `monotask space create "$REPO_NAME"`.
+- Store the `SPACE_ID`.
+
+### Idea Board
+- List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose title is `monomind-idea`. (There is no "board view" command -- column list reveals the board structure.)
+- If the `monomind-idea` board does not exist:
+  1. Create it: `monotask board create "monomind-idea" --json` -- store the returned `BOARD_ID`.
+  2. Add it to the space: `monotask space boards add $SPACE_ID $BOARD_ID`.
+  3. Create these columns in order:
+     - `New`
+     - `Evaluated`
+     - `Elaborated`
+     - `Tasked`
+     - `Iced`
+     - `Rejected`
+- Store all column IDs mapped by name (e.g., `COL_NEW`, `COL_EVALUATED`, `COL_ELABORATED`, `COL_TASKED`, `COL_ICED`, `COL_REJECTED`).
+
+---
+
+## Step 3: Research Swarm -- Generate Ideas
+
+Spawn 3-5 `researcher` agents in parallel using the Agent tool (mesh topology). Each agent receives:
+
+- The user's prompt: `$ARGUMENTS`
+- The `PROJECT_CONTEXT` string from Step 1
+
+Each agent should generate ideas as a JSON array. There is no hard cap -- generate as many or as few as the topic warrants:
+```json
+[
+  { "title": "Short idea title", "description": "2-3 sentence description of the idea, what it solves, and why it matters." }
+]
+```
+
+After all agents complete:
+1. Merge all idea arrays.
+2. Deduplicate by title similarity (fuzzy match -- drop ideas whose titles are >80% similar to an already-kept idea).
+3. For each unique idea, create a card in the `New` column:
+   ```bash
+   monotask card create $BOARD_ID $COL_NEW "<title>" --json
+   monotask card comment add $BOARD_ID $CARD_ID "<description>"
+   ```
+
+If zero ideas were generated after deduplication, report "No ideas generated by the research swarm." and STOP.
+
+---
+
+## Step 4: Evaluator -- Assess Each Idea
+
+Spawn a single `Product Manager` agent via the Agent tool. Provide it with:
+- All ideas (titles + descriptions)
+- The `PROJECT_CONTEXT`
+- The user's original prompt: `$ARGUMENTS`
+
+For EACH idea, the agent must return one of three verdicts, along with an **impact** score (0-10) and an **effort** score (0-10):
+
+| Verdict | Action |
+|---------|--------|
+| **evaluated** | Idea is worth pursuing. Include a `skipElaboration` boolean: `true` if the idea is straightforward and needs no further research, `false` if edge cases should be explored. Include a 1-2 sentence value statement. Include `impact` (0-10, how much value it adds) and `effort` (0-10, how much work it requires). |
+| **iced** | Idea might have potential but needs a question answered first. Include the blocking question. Include `impact` and `effort` estimates. |
+| **rejected** | Idea is out of scope, infeasible, or low value. Include a 1-sentence reason. |
+
+For each verdict, update the monotask board:
+
+- **evaluated**: Move card to `Evaluated`. Set impact and effort. Add comment with the value statement.
+  ```bash
+  monotask card move $BOARD_ID $CARD_ID $COL_EVALUATED --json
+  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
+  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
+  monotask card comment add $BOARD_ID $CARD_ID "Value: <value statement>"
+  ```
+- **iced**: Move card to `Iced`. Set impact and effort estimates. Add comment with the blocking question.
+  ```bash
+  monotask card move $BOARD_ID $CARD_ID $COL_ICED --json
+  monotask card set-impact $BOARD_ID $CARD_ID <0-10>
+  monotask card set-effort $BOARD_ID $CARD_ID <0-10>
+  monotask card comment add $BOARD_ID $CARD_ID "Blocked: <question>"
+  ```
+- **rejected**: Move card to `Rejected`. Add comment with the reason.
+  ```bash
+  monotask card move $BOARD_ID $CARD_ID $COL_REJECTED --json
+  monotask card comment add $BOARD_ID $CARD_ID "Rejected: <reason>"
+  ```
+
+If ALL ideas were iced or rejected, output a summary table of verdicts and STOP.
+
+---
+
+## Step 5: Elaborator -- Add Edge Cases (conditional)
+
+Check if ANY evaluated ideas have `skipElaboration: false`.
+
+**If ALL evaluated ideas have `skipElaboration: true`:**
+- Move each directly from `Evaluated` to `Elaborated`:
+  ```bash
+  monotask card move $BOARD_ID $CARD_ID $COL_ELABORATED --json
+  ```
+- Skip spawning the elaborator agent entirely.
+
+**Otherwise**, spawn two agents in parallel via the Agent tool:
+
+1. A `feature-dev:code-explorer` agent — deep-dives into the existing codebase to trace execution paths, map dependencies, and surface internal constraints relevant to each idea.
+2. A `researcher` agent (with WebSearch capability) — searches the internet for prior art, external edge cases, and potential technical pitfalls.
+
+Provide both agents with:
+- All evaluated ideas that have `skipElaboration: false`
+- The `PROJECT_CONTEXT`
+
+After both agents complete, merge their findings per idea. For each idea needing elaboration:
+1. Research edge cases, prior art, codebase constraints, and potential technical pitfalls.
+2. Add findings as comments on the card:
+   ```bash
+   monotask card comment add $BOARD_ID $CARD_ID "Edge cases: <findings>"
+   monotask card comment add $BOARD_ID $CARD_ID "Technical notes: <notes>"
+   ```
+3. If no blocking issues found, move to `Elaborated`:
+   ```bash
+   monotask card move $BOARD_ID $CARD_ID $COL_ELABORATED --json
+   ```
+4. If a blocking issue IS found, move to `Iced` with a comment explaining the issue:
+   ```bash
+   monotask card move $BOARD_ID $CARD_ID $COL_ICED --json
+   monotask card comment add $BOARD_ID $CARD_ID "Blocked during elaboration: <issue>"
+   ```
+
+Also move any `skipElaboration: true` ideas directly to `Elaborated`.
+
+---
+
+## Step 6: Task Decomposer -- Break Ideas into Subtasks
+
+### Task Board Setup
+- Check if a `monomind-task` board exists in the space (same lookup method as Step 2).
+- If not, create it with these columns:
+  - `Backlog`
+  - `Todo`
+  - `In Progress`
+  - `Review`
+  - `Human in Loop`
+  - `Done`
+- Store column IDs (especially `COL_BACKLOG`).
+
+### Decomposition
+Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
+- All ideas in the `Elaborated` column (titles, descriptions, and all comments)
+- The `PROJECT_CONTEXT`
+
+For each elaborated idea, the agent must:
+1. Break it into 2-6 actionable subtasks. Each subtask should have a clear title, a 1-2 sentence description of what to implement, and the recommended **agent type** to assign for implementation (e.g., `backend-dev`, `Frontend Developer`, `coder`, `Security Engineer`). Pick the agent type from the available agents list that best matches the subtask's domain.
+2. Create each subtask as a card in the `Backlog` column of the `monomind-task` board, including the agent type:
+   ```bash
+   monotask card create $TASK_BOARD_ID $COL_BACKLOG "<subtask title>" --json
+   monotask card comment add $TASK_BOARD_ID $SUBTASK_CARD_ID "<subtask description>"
+   monotask card comment add $TASK_BOARD_ID $SUBTASK_CARD_ID "Assigned agent: <agent type>"
+   ```
+3. Comment on the original idea card listing all subtask titles with their assigned agents:
+   ```bash
+   monotask card comment add $BOARD_ID $IDEA_CARD_ID "Subtasks created: <title> (agent: <type>), <title> (agent: <type>), ..."
+   ```
+4. Move the idea card to `Tasked`:
+   ```bash
+   monotask card move $BOARD_ID $IDEA_CARD_ID $COL_TASKED --json
+   ```
+
+**If the architect has doubts** about decomposing an idea (unclear scope, missing info), they should:
+- Add a comment with the question
+- Move the idea to `Iced` instead of `Tasked`
+
+---
+
+## Step 7: Final Summary
+
+Output a summary table:
+
+```
+| # | Idea                        | Status   | Subtasks |
+|---|-----------------------------|----------|----------|
+| 1 | <title>                     | Tasked   | 4        |
+| 2 | <title>                     | Iced     | --       |
+| 3 | <title>                     | Rejected | --       |
+```
+
+Then output:
+- Total ideas generated: N
+- Ideas tasked: N (with M total subtasks in Backlog)
+- Ideas iced: N
+- Ideas rejected: N
+- Monotask space: `$REPO_NAME` (ID: `$SPACE_ID`)
+- Idea board: `monomind-idea` (ID: `$BOARD_ID`)
+- Task board: `monomind-task` (ID: `$TASK_BOARD_ID`)
+
+---
+
+## Step 8: Offer to Execute Tasks
+
+If there are any tasked ideas (subtasks in Backlog), ask the user:
+
+> **M subtasks are ready in the backlog.** Want me to start executing them now?
+>
+> Say **yes** to launch `/monomind:do` — it will pick up tasks one by one, execute them with the assigned agent, review for bugs, and loop every 2 minutes until the queue is empty.
+
+If the user says yes (or any affirmative), invoke the Skill tool with:
+```
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID")
+```
+
+This passes the exact space and board IDs so `monomind:do` skips discovery and starts executing immediately.

package/.claude/commands/monomind-repeat.md

@@ -0,0 +1,95 @@
+---
+name: monomind-repeat
+description: "Monomind — Repeat a prompt on a schedule — default 15 min interval, 10 repetitions"
+---
+
+## Argument Parsing
+
+Parse `$ARGUMENTS` for the following (in any order):
+
+- `--every <minutes>` — interval between repetitions in minutes (default: `15`)
+- `--times <count>` — total number of repetitions (default: `10`)
+- Everything else is the **prompt** to repeat
+
+**Examples:**
+```
+/monomind:repeat --every 5 --times 20 check if the build is passing
+/monomind:repeat --every 30 run /monomind:do
+/monomind:repeat check deployment status
+```
+
+If `$ARGUMENTS` is empty or contains only flags with no prompt, output this and STOP:
+> **Usage:** `/monomind:repeat [--every <minutes>] [--times <count>] <prompt>`
+>
+> Defaults: every 15 minutes, 10 times.
+>
+> Examples:
+> - `/monomind:repeat check deployment status`
+> - `/monomind:repeat --every 5 --times 20 run tests and report`
+> - `/monomind:repeat --every 30 /monomind:do --space abc --board def`
+
+---
+
+## Step 1: Initialize
+
+Extract:
+- `INTERVAL` — from `--every` flag, default `15` (minutes)
+- `MAX_REPS` — from `--times` flag, default `10`
+- `PROMPT` — everything remaining after flags are removed
+- `CURRENT_REP` — starts at `1`
+
+Output:
+```
+[monomind:repeat] Starting: "<PROMPT>"
+  Interval: every INTERVAL minutes
+  Repetitions: MAX_REPS total
+  Run 1/MAX_REPS starting now...
+```
+
+---
+
+## Step 2: Execute the Prompt
+
+Run the `PROMPT` as if the user typed it directly. This means:
+- If the prompt starts with `/`, invoke it as a slash command via the Skill tool
+- Otherwise, treat it as a normal user message and respond accordingly
+
+---
+
+## Step 3: Report and Schedule Next
+
+After execution completes, output:
+```
+[monomind:repeat] Run CURRENT_REP/MAX_REPS complete. Next in INTERVAL minutes...
+```
+
+Increment `CURRENT_REP`.
+
+If `CURRENT_REP > MAX_REPS`, output:
+```
+[monomind:repeat] All MAX_REPS repetitions complete.
+```
+STOP. Do NOT schedule another wake-up.
+
+Otherwise, use `ScheduleWakeup` with:
+- `delaySeconds`: `INTERVAL * 60`
+- `prompt`: `/monomind:repeat --every INTERVAL --times MAX_REPS --rep CURRENT_REP PROMPT`
+- `reason`: `"repeat run CURRENT_REP/MAX_REPS of: PROMPT"`
+
+---
+
+## Internal Flag: `--rep`
+
+When `--rep <N>` is present in arguments, this is a continuation from a previous wake-up:
+- Set `CURRENT_REP` to `N` instead of `1`
+- Skip the initialization output from Step 1
+- Go directly to Step 2 (execute) with output:
+  ```
+  [monomind:repeat] Run N/MAX_REPS starting...
+  ```
+
+---
+
+## Interruption
+
+The user can stop the loop at any time by interrupting. The next scheduled wake-up simply won't fire.

package/.claude/commands/optimization/README.md

@@ -0,0 +1,9 @@
+# Optimization Commands
+
+Commands for optimization operations in Monomind.
+
+## Available Commands
+
+- [topology-optimize](./topology-optimize.md)
+- [parallel-execute](./parallel-execute.md)
+- [cache-manage](./cache-manage.md)

package/.claude/commands/optimization/auto-topology.md

@@ -0,0 +1,62 @@
+# Automatic Topology Selection
+
+## Purpose
+Automatically select the optimal swarm topology based on task complexity analysis.
+
+## How It Works
+
+### 1. Task Analysis
+The system analyzes your task description to determine:
+- Complexity level (simple/medium/complex)
+- Required agent types
+- Estimated duration
+- Resource requirements
+
+### 2. Topology Selection
+Based on analysis, it selects:
+- **Star**: For simple, centralized tasks
+- **Mesh**: For medium complexity with flexibility needs
+- **Hierarchical**: For complex tasks requiring structure
+- **Ring**: For sequential processing workflows
+
+### 3. Example Usage
+
+**Simple Task:**
+```
+Tool: mcp__monomind__task_orchestrate
+Parameters: {"task": "Fix typo in README.md"}
+Result: Automatically uses star topology with single agent
+```
+
+**Complex Task:**
+```
+Tool: mcp__monomind__task_orchestrate
+Parameters: {"task": "Refactor authentication system with JWT, add tests, update documentation"}
+Result: Automatically uses hierarchical topology with architect, coder, and tester agents
+```
+
+## Benefits
+- 🎯 Optimal performance for each task type
+- 🤖 Automatic agent assignment
+- ⚡ Reduced setup time
+- 📊 Better resource utilization
+
+## Hook Configuration
+The pre-task hook automatically handles topology selection:
+```json
+{
+  "command": "npx monomind hook pre-task --optimize-topology"
+}
+```
+
+## Direct Optimization
+```
+Tool: mcp__monomind__topology_optimize
+Parameters: {"swarmId": "current"}
+```
+
+## CLI Usage
+```bash
+# Auto-optimize topology via CLI
+npx monomind optimize topology
+```

package/.claude/commands/optimization/cache-manage.md

@@ -0,0 +1,25 @@
+# cache-manage
+
+Manage operation cache for performance.
+
+## Usage
+```bash
+npx monomind optimization cache-manage [options]
+```
+
+## Options
+- `--action <type>` - Action (view, clear, optimize)
+- `--max-size <mb>` - Maximum cache size
+- `--ttl <seconds>` - Time to live
+
+## Examples
+```bash
+# View cache stats
+npx monomind optimization cache-manage --action view
+
+# Clear cache
+npx monomind optimization cache-manage --action clear
+
+# Set limits
+npx monomind optimization cache-manage --max-size 100 --ttl 3600
+```

package/.claude/commands/optimization/parallel-execution.md

@@ -0,0 +1,50 @@
+# Parallel Task Execution
+
+## Purpose
+Execute independent subtasks in parallel for maximum efficiency.
+
+## Coordination Strategy
+
+### 1. Task Decomposition
+```
+Tool: mcp__monomind__task_orchestrate
+Parameters: {
+  "task": "Build complete REST API with auth, CRUD operations, and tests",
+  "strategy": "parallel",
+  "maxAgents": 8
+}
+```
+
+### 2. Parallel Workflows
+The system automatically:
+- Identifies independent components
+- Assigns specialized agents
+- Executes in parallel where possible
+- Synchronizes at dependency points
+
+### 3. Example Breakdown
+For the REST API task:
+- **Agent 1 (Architect)**: Design API structure
+- **Agent 2-3 (Coders)**: Implement auth & CRUD in parallel
+- **Agent 4 (Tester)**: Write tests as features complete
+- **Agent 5 (Documenter)**: Update docs continuously
+
+## CLI Usage
+```bash
+# Execute parallel tasks via CLI
+npx monomind parallel "Build REST API" --max-agents 8
+```
+
+## Performance Gains
+- 🚀 2.8-4.4x faster execution
+- 💪 Optimal CPU utilization
+- 🔄 Automatic load balancing
+- 📈 Linear scalability with agents
+
+## Monitoring
+```
+Tool: mcp__monomind__swarm_monitor
+Parameters: {"interval": 1000, "swarmId": "current"}
+```
+
+Watch real-time parallel execution progress!

package/.claude/commands/optimization/topology-optimize.md

@@ -0,0 +1,25 @@
+# topology-optimize
+
+Optimize swarm topology for current workload.
+
+## Usage
+```bash
+npx monomind optimization topology-optimize [options]
+```
+
+## Options
+- `--analyze-first` - Analyze before optimizing
+- `--target <metric>` - Optimization target
+- `--apply` - Apply optimizations
+
+## Examples
+```bash
+# Analyze and suggest
+npx monomind optimization topology-optimize --analyze-first
+
+# Optimize for speed
+npx monomind optimization topology-optimize --target speed
+
+# Apply changes
+npx monomind optimization topology-optimize --target efficiency --apply
+```