@monoes/monomindcli 1.7.0 → 1.9.0

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

@@ -1,302 +0,0 @@
----
-name: monomind-createtask
-description: "Monomind — Ingest a prompt, file, or folder, deeply understand it, generate agent-optimized tasks on monotask with smart grouping, prerequisites, and session memory"
----
-
-If `$ARGUMENTS` is empty, output this and STOP:
-
-> **Usage:** `/monomind:createtask <prompt | path-to-file | path-to-folder>`
->
-> Examples:
-> - `/monomind:createtask Build a webhook delivery system with retries and dead-letter queue`
-> - `/monomind:createtask docs/superpowers/specs/2026-04-27-swarm-tab-redesign-design.md`
-> - `/monomind:createtask docs/superpowers/specs/`
->
-> This command deeply analyzes your input, generates an implementation plan, and creates **agent-optimized** tasks on monotask — grouped so each agent gets full context, with prerequisites ensuring execution order.
-
-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
-> ```
-
----
-
-## Step 1: Classify and Ingest Input
-
-Parse `$ARGUMENTS` to determine input type:
-
-### 1a: Detect input type
-
-- If `$ARGUMENTS` is an existing **file path** (check with `test -f`): `INPUT_TYPE=file`
-- If `$ARGUMENTS` is an existing **directory path** (check with `test -d`): `INPUT_TYPE=folder`
-- Otherwise: `INPUT_TYPE=prompt`
-
-### 1b: Collect raw content
-
-**If `INPUT_TYPE=prompt`:**
-- Store the text as `RAW_CONTENT`.
-
-**If `INPUT_TYPE=file`:**
-- Read the file using the Read tool.
-- Store the full contents as `RAW_CONTENT`.
-- Store filename as `INPUT_LABEL`.
-
-**If `INPUT_TYPE=folder`:**
-- List all files in the directory (non-recursive, skip hidden files):
-  ```bash
-  find "$ARGUMENTS" -maxdepth 2 -type f ! -name '.*' | head -30
-  ```
-- Read each file using the Read tool (up to 30 files, skip binary files).
-- Concatenate all contents with `--- FILE: <path> ---` separators as `RAW_CONTENT`.
-- Store folder path as `INPUT_LABEL`.
-
-### 1c: Enrich with knowledge systems
-
-Run ALL of the following in parallel (skip any that error):
-
-1. **Knowledge graph — suggest**: Call `mcp__monomind__graphify_suggest` with the first 200 chars of `RAW_CONTENT`.
-2. **Knowledge graph — query**: If any specific module/component names appear in `RAW_CONTENT`, call `mcp__monomind__graphify_query` for each (up to 5 queries).
-3. **Memory search**: Call `mcp__monomind__memory_search` with a summary of the input. Use top 5 results.
-4. **README**: Read `README.md` (first 200 lines). Skip if missing.
-5. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`.
-6. **Repo name**: Run `git remote get-url origin`, extract last path segment, strip `.git`. Fallback: `basename` of cwd. Store as `REPO_NAME`.
-
-Bundle everything into `FULL_CONTEXT` = `RAW_CONTENT` + graph results + memory results + README + manifest.
-
----
-
-## Step 2: Setup Monotask Space and Task Board
-
-### Space
-- Run `monotask space list` and check if a space named `$REPO_NAME` exists.
-- If not, create it: `monotask space create "$REPO_NAME"`.
-- Store `SPACE_ID`.
-
-### Task Board
-- List boards via `monotask board list --json`. For each board ID, run `monotask column list <BOARD_ID> --json` to find one whose columns contain `Todo` (the `monomind-task` board).
-- If the `monomind-task` board does not exist:
-  1. Create it: `monotask board create "monomind-task" --json` — store `TASK_BOARD_ID`.
-  2. Add to space: `monotask space boards add $SPACE_ID $TASK_BOARD_ID`.
-  3. Create columns in order:
-     - `Backlog`
-     - `Todo`
-     - `In Progress`
-     - `Review`
-     - `Human in Loop`
-     - `Done`
-- Store all column IDs mapped by name.
-
----
-
-## Step 3: Deep Analysis — Understand the Document
-
-Spawn a `Software Architect` agent via the Agent tool. Provide it with:
-
-- The complete `FULL_CONTEXT`
-- The user's original `$ARGUMENTS`
-
-The agent MUST produce a structured analysis:
-
-```json
-{
-  "summary": "2-3 sentence overview of what this document/prompt is about",
-  "goals": ["list of high-level goals or features described"],
-  "components": [
-    {
-      "name": "component or module name",
-      "description": "what it does",
-      "dependencies": ["other components it depends on"],
-      "files_likely_affected": ["paths from graphify or educated guesses"],
-      "shared_context_with": ["other component names that share state, models, or interfaces"]
-    }
-  ],
-  "technical_constraints": ["any constraints, tech stack requirements, or limitations mentioned"],
-  "acceptance_criteria": ["testable conditions for when this is done"],
-  "risks": ["potential pitfalls, ambiguities, or unknowns"],
-  "context_chains": [
-    {
-      "chain_name": "descriptive name for this context group",
-      "components": ["ordered list of components that share context and should be done by same agent or sequentially"],
-      "reason": "why these must share context (shared types, same file, state dependency, etc.)"
-    }
-  ]
-}
-```
-
-Store as `ANALYSIS`.
-
----
-
-## Step 4: Generate Agent-Optimized Implementation Plan
-
-Spawn a `planner` agent via the Agent tool. Provide it with:
-
-- The `ANALYSIS` from Step 3 (including `context_chains`)
-- The `FULL_CONTEXT`
-- The `REPO_NAME` and project info
-- **The Task Grouping Rules and Card Format from `monomind-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
-
-The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1).
-
-Store as `TASKS` array.
-
----
-
-## Step 5: Create Tasks, Store Memory, and Review
-
-Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
-
-| Parameter | Value |
-|-----------|-------|
-| `TASKS` | The array from Step 4 |
-| `TASK_BOARD_ID` | From Step 2 (or let the engine set up the board) |
-| `REPO_NAME` | From Step 1c |
-| `SOURCE_TAG` | `"monomind-createtask"` |
-| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
-| `PARENT_CARD_ID` | _(none — createtask has no parent card)_ |
-
-The engine will:
-1. Create all cards on the monotask board (Section 4)
-2. Store execution strategy in session memory (Section 5)
-3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
-4. Fix any blocker issues automatically, present warnings to user
-5. Present execution offer with mode recommendation (Section 7)
-
----
-
-## Step 7: Exploration Session — Suggest Missing Pieces
-
-After all tasks are created, spawn a **second** `Software Architect` agent (fresh context) via the Agent tool. Provide it with:
-
-- The `ANALYSIS` from Step 3
-- The complete list of `TASKS` already created (titles + descriptions + context groups)
-- The `FULL_CONTEXT`
-
-The agent must act as a **critical reviewer** and identify:
-
-```json
-{
-  "missing_pieces": [
-    {
-      "title": "What's missing",
-      "description": "Why this matters and what should be done",
-      "category": "testing | documentation | error-handling | monitoring | security | performance | accessibility | deployment | migration",
-      "context_group": "which existing context group this belongs to, or 'new'"
-    }
-  ],
-  "upcoming_plans": [
-    {
-      "title": "Natural follow-up work",
-      "description": "What this would add and why it's worth considering",
-      "category": "enhancement | optimization | scale | integration"
-    }
-  ]
-}
-```
-
-### Present to User
-
-Output the suggestions in a clear format:
-
-```
-## Missing Pieces
-
-| # | Category     | Title                              | Context Group | Description                |
-|---|-------------|------------------------------------|---------------|----------------------------|
-| 1 | testing     | Add integration tests for webhook  | webhook-chain | Currently only unit tests  |
-| 2 | security    | Rate-limit webhook endpoints       | independent   | Prevent abuse              |
-
-## Potential Follow-ups
-
-| # | Category     | Title                              | Description                |
-|---|-------------|------------------------------------|----------------------------|
-| 1 | enhancement | Add webhook analytics dashboard    | Track delivery rates       |
-```
-
-Then ask:
-
-> **Found N missing pieces and M potential follow-ups.**
->
-> Reply with the numbers you want to add as tasks (e.g., `1, 3, 5` or `all` or `none`).
-> Missing pieces will be added to their context group. Follow-ups go to **Backlog**.
-
-### Process User Selection
-
-If the user selects items:
-1. For each selected **missing piece**: Create a task card following the same grouping rules (Step 4). If it belongs to an existing context group, add prerequisite links. Add comment: `"Source: exploration — missing piece"`.
-2. For each selected **follow-up**: Create a task card in `Backlog`. Add comment: `"Source: exploration — follow-up suggestion"`.
-
-If the user says `none` or declines, skip.
-
----
-
-## Step 8: Final Summary
-
-Output:
-
-```
-## Task Creation Complete
-
-**Source:** <prompt text | file path | folder path>
-**Space:** $REPO_NAME (ID: $SPACE_ID)
-**Board:** monomind-task (ID: $TASK_BOARD_ID)
-**Execution strategy:** <parallel | minimal | sequential>
-
-### Context Groups
-
-| Group              | Tasks | Agent           | Mode       |
-|--------------------|-------|-----------------|------------|
-| <group name>       | 3     | backend-dev     | sequential |
-| <group name>       | 2     | Frontend Developer | sequential |
-| independent        | 4     | mixed           | parallel   |
-
-### All Tasks
-
-| # | Title                                   | Agent        | Priority | Group        | Prerequisites |
-|---|----------------------------------------|-------------|----------|--------------|---------------|
-| 1 | <title>                                | backend-dev | high     | api-chain    | —             |
-| 2 | <title>                                | backend-dev | high     | api-chain    | Task 1        |
-| 3 | <title>                                | coder       | medium   | independent  | —             |
-
-**Total:** N tasks (X in Todo, Y in Backlog)
-**Estimated effort:** Z points
-**Recommended mode:** <parallel | minimal | sequential> — <one-line reason>
-```
-
----
-
-## Step 9: Offer to Execute
-
-If there are tasks in Todo, ask:
-
-> **N tasks are ready for execution.** How do you want to run them?
->
-> 1. **Parallel** — Spawn one agent per context group + independent tasks run simultaneously. Fastest, best for independent work. (~N agents)
-> 2. **Minimal** — 2-3 agents: one per major context group, one for independents. Balanced cost/speed.
-> 3. **Sequential** — One agent processes tasks in order. Slowest but cheapest, best for heavy shared state.
->
-> Recommended: **<mode>** — <reason>
-
-If the user agrees or picks a mode, invoke:
-```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
-```

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

@@ -1,103 +0,0 @@
----
-name: monomind-help
-description: Show Monomind commands and usage
----
-
-# Monomind Commands
-
-## 🌊 Monomind: Agent Orchestration Platform
-
-Monomind is the ultimate multi-terminal orchestration platform that revolutionizes how you work with Claude Code.
-
-## Core Commands
-
-### 🚀 System Management
-- `./monomind start` - Start orchestration system
-- `./monomind start --ui` - Start with interactive process management UI
-- `./monomind status` - Check system status
-- `./monomind monitor` - Real-time monitoring
-- `./monomind stop` - Stop orchestration
-
-### 🤖 Agent Management
-- `./monomind agent spawn <type>` - Create new agent
-- `./monomind agent list` - List active agents
-- `./monomind agent info <id>` - Agent details
-- `./monomind agent terminate <id>` - Stop agent
-
-### 📋 Task Management
-- `./monomind task create <type> "description"` - Create task
-- `./monomind task list` - List all tasks
-- `./monomind task status <id>` - Task status
-- `./monomind task cancel <id>` - Cancel task
-- `./monomind task workflow <file>` - Execute workflow
-
-### 🧠 Memory Operations
-- `./monomind memory store "key" "value"` - Store data
-- `./monomind memory query "search"` - Search memory
-- `./monomind memory stats` - Memory statistics
-- `./monomind memory export <file>` - Export memory
-- `./monomind memory import <file>` - Import memory
-
-### ⚡ SPARC Development
-- `./monomind sparc "task"` - Run SPARC orchestrator
-- `./monomind sparc modes` - List all 17+ SPARC modes
-- `./monomind sparc run <mode> "task"` - Run specific mode
-- `./monomind sparc tdd "feature"` - TDD workflow
-- `./monomind sparc info <mode>` - Mode details
-
-### 🐝 Swarm Coordination
-- `./monomind swarm "task" --strategy <type>` - Start swarm
-- `./monomind swarm "task" --background` - Long-running swarm
-- `./monomind swarm "task" --monitor` - With monitoring
-- `./monomind swarm "task" --ui` - Interactive UI
-- `./monomind swarm "task" --distributed` - Distributed coordination
-
-### 🌍 MCP Integration
-- `./monomind mcp status` - MCP server status
-- `./monomind mcp tools` - List available tools
-- `./monomind mcp config` - Show configuration
-- `./monomind mcp logs` - View MCP logs
-
-### 🤖 Claude Integration
-- `./monomind claude spawn "task"` - Spawn Claude with enhanced guidance
-- `./monomind claude batch <file>` - Execute workflow configuration
-
-## 🌟 Quick Examples
-
-### Initialize with SPARC:
-```bash
-npx -y monomind@latest init --sparc
-```
-
-### Start a development swarm:
-```bash
-./monomind swarm "Build REST API" --strategy development --monitor --review
-```
-
-### Run TDD workflow:
-```bash
-./monomind sparc tdd "user authentication"
-```
-
-### Store project context:
-```bash
-./monomind memory store "project_requirements" "e-commerce platform specs" --namespace project
-```
-
-### Spawn specialized agents:
-```bash
-./monomind agent spawn researcher --name "Senior Researcher" --priority 8
-./monomind agent spawn developer --name "Lead Developer" --priority 9
-```
-
-## 🎯 Best Practices
-- Use `./monomind` instead of `npx monomind` after initialization
-- Store important context in memory for cross-session persistence
-- Use swarm mode for complex tasks requiring multiple agents
-- Enable monitoring for real-time progress tracking
-- Use background mode for tasks > 30 minutes
-
-## 📚 Resources
-- Documentation: https://github.com/nokhodian/claude-code-flow/docs
-- Examples: https://github.com/nokhodian/claude-code-flow/examples
-- Issues: https://github.com/nokhodian/claude-code-flow/issues

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

@@ -1,107 +0,0 @@
----
-name: monomind-memory
-description: Interact with Monomind memory system
----
-
-# 🧠 Monomind Memory System
-
-The memory system provides persistent storage for cross-session and cross-agent collaboration with CRDT-based conflict resolution.
-
-## Store Information
-```bash
-# Store with default namespace
-./monomind memory store "key" "value"
-
-# Store with specific namespace
-./monomind memory store "architecture_decisions" "microservices with API gateway" --namespace arch
-```
-
-## Query Memory
-```bash
-# Search across all namespaces
-./monomind memory query "authentication"
-
-# Search with filters
-./monomind memory query "API design" --namespace arch --limit 10
-```
-
-## Memory Statistics
-```bash
-# Show overall statistics
-./monomind memory stats
-
-# Show namespace-specific stats
-./monomind memory stats --namespace project
-```
-
-## Export/Import
-```bash
-# Export all memory
-./monomind memory export full-backup.json
-
-# Export specific namespace
-./monomind memory export project-backup.json --namespace project
-
-# Import memory
-./monomind memory import backup.json
-```
-
-## Cleanup Operations
-```bash
-# Clean entries older than 30 days
-./monomind memory cleanup --days 30
-
-# Clean specific namespace
-./monomind memory cleanup --namespace temp --days 7
-```
-
-## 🗂️ Namespaces
-- **default** - General storage
-- **agents** - Agent-specific data and state
-- **tasks** - Task information and results
-- **sessions** - Session history and context
-- **swarm** - Swarm coordination and objectives
-- **project** - Project-specific context
-- **spec** - Requirements and specifications
-- **arch** - Architecture decisions
-- **impl** - Implementation notes
-- **test** - Test results and coverage
-- **debug** - Debug logs and fixes
-
-## 🎯 Best Practices
-
-### Naming Conventions
-- Use descriptive, searchable keys
-- Include timestamp for time-sensitive data
-- Prefix with component name for clarity
-
-### Organization
-- Use namespaces to categorize data
-- Store related data together
-- Keep values concise but complete
-
-### Maintenance
-- Regular backups with export
-- Clean old data periodically
-- Monitor storage statistics
-- Compress large values
-
-## Examples
-
-### Store SPARC context:
-```bash
-./monomind memory store "spec_auth_requirements" "OAuth2 + JWT with refresh tokens" --namespace spec
-./monomind memory store "arch_api_design" "RESTful microservices with GraphQL gateway" --namespace arch
-./monomind memory store "test_coverage_auth" "95% coverage, all tests passing" --namespace test
-```
-
-### Query project decisions:
-```bash
-./monomind memory query "authentication" --namespace arch --limit 5
-./monomind memory query "test results" --namespace test
-```
-
-### Backup project memory:
-```bash
-./monomind memory export project-$(date +%Y%m%d).json --namespace project
-```

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

@@ -1,149 +0,0 @@
----
-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`
-- `LOOP_ID` — generate as `repeat-<unix-timestamp-ms>` (use `date +%s000`)
-
-Write the initial loop state file so the dashboard can track this run:
-```bash
-mkdir -p .monomind/loops
-LOOP_ID="repeat-$(date +%s%3N)"
-cat > ".monomind/loops/${LOOP_ID}.json" << EOF
-{
-  "id": "${LOOP_ID}",
-  "type": "repeat",
-  "prompt": "PROMPT",
-  "interval": INTERVAL,
-  "currentRep": 1,
-  "maxReps": MAX_REPS,
-  "startedAt": $(date +%s%3N),
-  "lastRunAt": $(date +%s%3N),
-  "nextRunAt": $(date +%s%3N),
-  "status": "running"
-}
-EOF
-```
-
-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
-
-Before scheduling the next run, check if a stop was requested:
-```bash
-[ -f ".monomind/loops/${LOOP_ID}.stop" ] && echo "STOP_REQUESTED=true"
-```
-If `STOP_REQUESTED=true`, output `[monomind:repeat] Stop requested via dashboard. Halting.` and remove the state files:
-```bash
-rm -f ".monomind/loops/${LOOP_ID}.json" ".monomind/loops/${LOOP_ID}.stop"
-```
-Then STOP.
-
-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.
-```
-Remove the state file:
-```bash
-rm -f ".monomind/loops/${LOOP_ID}.json"
-```
-STOP. Do NOT schedule another wake-up.
-
-Otherwise, update the loop state before scheduling:
-```bash
-NEXT_AT=$(( $(date +%s%3N) + INTERVAL * 60 * 1000 ))
-cat > ".monomind/loops/${LOOP_ID}.json" << EOF
-{
-  "id": "${LOOP_ID}",
-  "type": "repeat",
-  "prompt": "PROMPT",
-  "interval": INTERVAL,
-  "currentRep": CURRENT_REP,
-  "maxReps": MAX_REPS,
-  "startedAt": STARTED_AT,
-  "lastRunAt": $(date +%s%3N),
-  "nextRunAt": ${NEXT_AT},
-  "status": "running"
-}
-EOF
-```
-
-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.