@quadslab.io/discord-mcp 2.0.1 → 2.1.0

package/.claude/skills/create-rich-plan/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: create-rich-plan
+description: Generate and save a comprehensive, enriched implementation plan with architectural decisions, risk analysis, and detailed steps
+allowed-tools: mcp__quadcode__create_plan, mcp__quadcode__add_plan_step, mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__list_issues, mcp__quadcode__get_issue, Read, Glob, Grep
+user-invocable: true
+argument-hint: <feature description, idea ID, or issue ID>
+---
+
+# Create Rich Plan Skill
+
+Generate and save a comprehensive implementation plan with full enrichment data including architectural decisions, risk analysis, codebase context, and detailed typed steps with acceptance criteria, target files, effort estimates, dependencies, and verification strategies.
+
+## Process
+
+1. **Parse arguments**:
+   - If $ARGUMENTS looks like a UUID, try to fetch it as an idea ID or issue ID
+   - If $ARGUMENTS is text, treat it as a feature description
+   - If no argument, ask the user what they want to plan
+
+2. **Gather context**:
+   - If linked to an idea: fetch full idea details with `mcp__quadcode__get_idea`
+   - If linked to an issue: fetch full issue details with `mcp__quadcode__get_issue`
+   - Use `Glob` and `Read` to explore the codebase structure
+   - Use `Grep` to find relevant code patterns and existing implementations
+   - Identify the tech stack, frameworks, and conventions used
+
+3. **Document architectural decisions**:
+   For each significant design choice, capture:
+   - **decision**: What was decided (e.g., "Use SQLite for storage")
+   - **rationale**: Why this choice was made (e.g., "Embedded DB avoids external dependencies")
+
+4. **Identify risks and mitigations**:
+   - Schema/data migration risks
+   - Breaking changes to existing features
+   - Performance implications
+   - External dependency risks
+   - Capture these as `risk_notes` text
+
+5. **Capture codebase context**:
+   - Key files and their roles
+   - Existing patterns to follow
+   - Important constraints or conventions
+   - Store as `context` text
+
+6. **Break into typed steps**:
+   For each step, provide:
+   - **title**: Clear, actionable title
+   - **description**: Detailed description of what to do
+   - **step_type**: One of: research, design, implement, test, verify, document
+   - **acceptance_criteria**: List of criteria that define "done" for this step
+   - **target_files**: List of file paths this step will create/modify
+   - **estimated_effort**: low, medium, or high
+   - **dependencies**: List of step numbers this step depends on (e.g., ["1", "2"])
+   - **verification_strategy**: How to verify the step is complete:
+     - method: "build", "test", "grep_check", "manual_review", "file_exists"
+     - pattern: Optional search pattern
+     - command: Optional command to run
+   - **code_context**: Relevant code snippets or notes for the implementer
+
+   Step ordering should follow this pattern:
+   1. Research/discovery steps first
+   2. Design/planning steps
+   3. Implementation steps (ordered by dependency)
+   4. Testing steps
+   5. Verification/integration steps
+   6. Documentation steps (if applicable)
+
+7. **Save the plan**:
+   Use `mcp__quadcode__create_plan` with ALL enrichment fields:
+   ```
+   title, description, idea_id/issue_id,
+   architectural_decisions, risk_notes, context,
+   steps (with all enrichment fields)
+   ```
+
+8. **Report results**:
+   - Show the created plan summary
+   - List all steps with their types and effort estimates
+   - Highlight any risks identified
+   - Suggest which step to start with
+
+## Guidelines
+
+- Keep steps atomic and completable in one session
+- Every implementation step should have at least one acceptance criterion
+- Target files should be actual paths found via codebase exploration
+- Dependencies should reference step numbers (e.g., "1", "2"), not IDs
+- Use verification strategies that can be checked programmatically when possible
+- Be specific about code context - include function names, types, patterns to follow
+- Risk notes should include both the risk AND a mitigation strategy

package/.claude/skills/decompose-spec/SKILL.md

@@ -0,0 +1,32 @@
+---
+description: Break a plan's spec into high-level epic steps. Creates parent steps representing major work areas.
+argument-hint: <plan_id>
+allowed-tools: mcp__quadcode__get_plan, mcp__quadcode__add_plan_step, mcp__quadcode__update_plan, Read, Glob, Grep
+---
+
+# Decompose Spec into Epics
+
+Read a plan's spec document and break it into 8-15 high-level parent steps (epics) representing major work areas.
+
+## Process
+
+1. Get the plan by ID: `mcp__quadcode__get_plan`
+2. Read the `specContent` field
+3. If the plan's `specType` is 'feature' or 'refactor', explore the codebase to understand existing architecture
+4. Analyze the spec and identify 8-15 major work areas / subsystems / phases
+5. For each area, create a parent step via `mcp__quadcode__add_plan_step`:
+   - `title`: Clear, descriptive name for the work area (e.g., "Authentication System", "Database Layer")
+   - `description`: 2-3 sentences summarizing what this area covers
+   - `step_type`: Classify as 'research', 'design', 'implement', 'test', 'verify', or 'document'
+   - `estimated_effort`: 'low', 'medium', or 'high' based on scope
+   - Do NOT set `parent_step_id` — these ARE the parents
+6. Set plan status to `decomposing` if not already
+
+## Guidelines
+
+- Create steps that represent LOGICAL GROUPINGS, not sequential tasks
+- Each parent step should be independently workable by a team
+- Think about: infrastructure, data model, API, frontend, auth, testing, deployment, docs
+- Order parents roughly by dependency (foundational work first)
+- Don't create child steps — that's what `/expand-epic` does
+- Keep titles concise but descriptive

package/.claude/skills/detect-environments/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: detect-environments
+description: Scan the system for available terminal environments (Visual Studio, Git Bash, etc.) and register them in QuadCode.
+allowed-tools: mcp__quadcode__detect_environments, mcp__quadcode__list_environments, mcp__quadcode__set_default_environment
+user-invocable: true
+argument-hint: [set-default]
+---
+
+# Detect Terminal Environments Skill
+
+Scan the system for available development environments and register them in QuadCode.
+
+## What Gets Detected
+
+### On Windows
+- **Default CMD** - Windows Command Prompt
+- **Default PowerShell** - Windows PowerShell
+- **Git Bash** - Git for Windows Bash shell (if installed at standard location)
+- **Visual Studio Native Tools** - For each VS installation found:
+  - VS 2022/2019 Community/Professional/Enterprise/BuildTools
+  - Both x64 and x86 architectures
+  - Automatically configures vcvarsall.bat init commands
+
+### On macOS/Linux
+- **Default Bash** - System Bash shell
+
+## Process
+
+1. **Run detection** using `mcp__quadcode__detect_environments`
+   - This scans standard installation paths
+   - Registers found environments as built-in
+   - Preserves any existing custom environments
+
+2. **Show results**:
+   - List all detected environments
+   - Show which are available vs unavailable
+   - Note any VS installations found with versions
+
+3. **If $ARGUMENTS contains "default" or user wants**:
+   - Suggest setting a default environment
+   - Use `mcp__quadcode__set_default_environment` to set it
+
+## After Detection
+
+Inform the user they can:
+- Assign environments to scripts using `/assign-environment`
+- Create custom environments using `/setup-environment`
+- Set a default environment for new scripts
+
+## Example Output
+
+```
+Detected 5 terminal environments:
+- Default CMD (system-cmd) ✓
+- Default PowerShell (system-powershell) ✓
+- Git Bash (system-bash) ✓
+- VS 2022 Community x64 (vs-native) ✓
+- VS 2022 Community x86 (vs-native) ✓
+
+Would you like to set a default environment for new scripts?
+```

package/.claude/skills/dispatch/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: dispatch
+description: Review the issues board and launch a coordinator agent that proposes a mission swarm. The coordinator analyzes open issues, produces a structured proposal, and waits for human approval before any agents are spawned.
+allowed-tools: mcp__quadcode__list_issues_filtered, mcp__quadcode__list_mission_templates, mcp__quadcode__get_issue, mcp__quadcode__get_mission_template, mcp__quadcode__create_mission, mcp__quadcode__add_mission_member, mcp__quadcode__list_agent_definitions, mcp__quadcode__create_mission_proposal, mcp__quadcode__list_mission_proposals, mcp__quadcode__get_mission_proposal, Read
+user-invocable: true
+argument-hint: [goal or focus area]
+---
+
+# Dispatch Skill — Coordinator Proposal Workflow
+
+You are the DISPATCH AGENT. Your job is to analyze open issues and produce a structured `MissionProposal` that the user can review and approve before any worker agents are spawned.
+
+**This is a two-phase workflow:**
+1. You (dispatch agent) set up the mission and produce a proposal
+2. The user approves the proposal in the MissionDashboard → workers spawn
+
+## Phase 1: Analyze the Work
+
+1. **Get open issues** using `mcp__quadcode__list_issues_filtered` with status `todo,in_progress,blocked`
+
+2. **Examine each issue** for:
+   - Labels, keywords, target files
+   - Priority (critical/high first)
+   - Dependencies (`blocked_by` — don't assign blocked issues)
+   - Natural groupings (related feature areas)
+
+3. **Group issues into parallelizable batches:**
+   - Each batch should be assignable to one agent
+   - Batches should have minimal file overlap (to avoid merge conflicts)
+   - Blocked issues should wait until their dependencies are done
+
+## Phase 2: Produce the Proposal
+
+4. **Call `mcp__quadcode__create_mission_proposal`** with:
+   - `mission_id`: The ID of the current mission (create one with `mcp__quadcode__create_mission` if needed)
+   - `goal`: The overall objective in 1-2 sentences
+   - `proposed_agents`: Array of agent entries, each with:
+     - `role`: Agent role (frontend, backend, fullstack, qa, docs, etc.)
+     - `name`: Descriptive name (e.g. "Frontend Agent", "API Agent")
+     - `assigned_issue_ids`: Issue IDs this agent should handle
+     - `allowed_files`: Target files this agent will touch (from issue `target_files`)
+     - `rationale`: Why these issues are grouped together
+   - `estimated_cost_usd`: Cost estimate (assume $0.015/1k tokens, ~50k tokens/agent/hour)
+   - `estimated_minutes`: Parallelized time estimate
+   - `rationale`: Overall parallelization strategy and why this grouping makes sense
+
+5. **Output a summary** of the proposal you filed:
+   - Number of agents proposed
+   - Issue breakdown per agent
+   - Estimated cost and time
+   - How to approve: "Open the MissionDashboard → Proposals tab → Approve"
+
+## Coordinator Cost Estimation Formula
+
+```
+per_agent_cost = estimated_hours × 50_000_tokens × $0.015/1000 = $0.75/hour per agent
+total_cost = number_of_agents × per_agent_cost × estimated_hours
+```
+
+If `total_cost > 2 × single_agent_cost` AND tasks have high interdependency, warn the user:
+> "High coordination overhead detected. Consider running sequentially."
+
+## Rules
+
+- **DO NOT spawn workers yourself** — only create the proposal and wait for approval
+- Prioritize by urgency (critical/high priority issues first)
+- Assign each issue to exactly ONE agent (no duplicates)
+- Assign unblocked issues only — note blocked issues as "waiting on dependencies"
+- Keep file scopes non-overlapping where possible
+- If there are fewer than 2 parallelizable issues, note that a single agent may be more efficient
+- If a focus area argument was provided (`$ARGUMENTS`), filter to issues in that area
+
+## Output Format
+
+After filing the proposal, output:
+
+```
+✅ Mission proposal filed.
+
+**Goal:** [goal]
+**Agents proposed:** [N]
+**Estimated cost:** $[X]-$[Y]
+**Estimated time:** ~[N] minutes (parallelized)
+
+Agent breakdown:
+1. [Agent Name] ([role]) → Issues: [QU-X, QU-Y] | Files: [file1, file2]
+2. [Agent Name] ([role]) → Issues: [QU-Z] | Files: [file3]
+
+To launch: Open MissionDashboard → select this mission → Proposals tab → Review & Approve
+```

package/.claude/skills/estimate-complexity/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: estimate-complexity
+description: Review each idea and estimate implementation complexity (low/medium/high), considering dependencies, scope, and technical difficulty.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__add_tag, mcp__quadcode__add_idea_note, Read, Grep, Glob
+user-invocable: true
+argument-hint: [filter]
+---
+
+# Estimate Complexity Skill
+
+Review QuadCode ideas and estimate their implementation complexity.
+
+## Process
+
+1. **Retrieve ideas** to analyze:
+   - If a filter is provided ($ARGUMENTS), focus on those ideas (by tag or ID range)
+   - Otherwise, analyze all ideas using `mcp__quadcode__list_ideas`
+
+2. **For each idea, evaluate**:
+
+   ### Scope Assessment
+   - How many features/components are involved?
+   - Is it a single change or system-wide?
+   - Does it require UI, backend, or both?
+
+   ### Technical Difficulty
+   - Does it require new technologies or patterns?
+   - Are there complex algorithms involved?
+   - Does it involve performance-critical code?
+   - Security or data integrity concerns?
+
+   ### Dependencies
+   - External libraries or APIs needed?
+   - Other features that must exist first?
+   - Breaking changes to existing code?
+
+   ### Codebase Impact
+   - Search codebase with `Grep` and `Glob` to understand scope
+   - How many files would need modification?
+   - Is there existing similar code to build on?
+
+3. **Assign complexity level**:
+   - **Low**: 1-2 hours, single file, clear implementation path
+   - **Medium**: 2-8 hours, multiple files, some unknowns
+   - **High**: 1+ days, significant architecture, many unknowns
+
+4. **Add complexity tags** using `mcp__quadcode__add_tag`:
+   - `complexity-low`
+   - `complexity-medium`
+   - `complexity-high`
+
+5. **Add detailed notes** using `mcp__quadcode__add_idea_note`:
+   - Set `author` to `"estimate-complexity"`
+   - Include reasoning for the estimate
+   - Key risk factors
+   - Prerequisites or dependencies
+   - Suggested approach
+
+   Example:
+   ```
+   mcp__quadcode__add_idea_note({
+     idea_id: "...",
+     body: "Complexity: MEDIUM\n\nReasoning:\n- Requires changes to 3-4 files\n- Builds on existing pattern in database.ts\n\nRisks:\n- May need schema migration\n\nSuggested approach:\n1. Add type definitions first\n2. Implement database layer\n3. Add MCP tool",
+     author: "estimate-complexity"
+   })
+   ```
+
+6. **Generate report**:
+
+```
+## Complexity Estimation Report
+
+### Summary
+- Ideas analyzed: X
+- Low complexity: X (estimated Y hours total)
+- Medium complexity: X (estimated Y hours total)
+- High complexity: X (estimated Y hours total)
+
+### Quick Wins (Low Complexity)
+| ID | Idea | Est. Time | Notes |
+|----|------|-----------|-------|
+| 1  | ...  | 1 hour    | ...   |
+
+### Medium Effort
+| ID | Idea | Est. Time | Dependencies | Notes |
+|----|------|-----------|--------------|-------|
+| 2  | ...  | 4 hours   | None         | ...   |
+
+### Major Projects (High Complexity)
+| ID | Idea | Est. Time | Dependencies | Risk Factors |
+|----|------|-----------|--------------|--------------|
+| 3  | ...  | 2 days    | Feature X    | ...          |
+
+### Recommendations
+- Start with: [quick wins list]
+- Block dependencies: [ideas that should be done first]
+- Needs clarification: [ambiguous ideas]
+```
+
+## Filter Options
+
+If filter argument is provided ($ARGUMENTS):
+- `untagged` - Only ideas without complexity tags
+- `low` / `medium` / `high` - Re-evaluate specific complexity level
+- Tag name (e.g., `mcp`) - Only ideas with that tag
+- Idea ID - Estimate single idea in detail
+
+## Notes vs Suggestions
+
+- **Notes** (`add_idea_note`): Complexity analysis, reasoning, risk factors, approach
+- **Suggestions** (`add_suggestion`): Only for text/wording improvements to the idea itself
+
+## Notes
+
+- Be conservative with estimates - add buffer for unknowns
+- Consider the developer's familiarity with the codebase
+- Flag ideas that need more information before accurate estimation
+- Identify ideas that could be broken into smaller pieces

package/.claude/skills/expand-epic/SKILL.md

@@ -0,0 +1,38 @@
+---
+description: Expand a parent step (epic) into detailed child steps with full enrichment data.
+argument-hint: <plan_id> <step_id>
+allowed-tools: mcp__quadcode__get_plan, mcp__quadcode__add_plan_step, mcp__quadcode__update_plan_step, Read, Glob, Grep
+---
+
+# Expand Epic into Child Steps
+
+Take a parent step and generate 5-20 detailed child steps underneath it, with full enrichment data.
+
+## Process
+
+1. Parse arguments: plan_id (first arg), step_id (second arg)
+2. Get the plan: `mcp__quadcode__get_plan`
+3. Find the parent step by step_id from the plan's steps
+4. Read the plan's `specContent` for context
+5. If plan's `specType` is 'feature' or 'refactor', explore relevant parts of the codebase
+6. Generate 5-20 child steps, each via `mcp__quadcode__add_plan_step` with:
+   - `plan_id`: the plan ID
+   - `parent_step_id`: the epic's step_id (THIS IS REQUIRED — it links the child to its parent)
+   - `title`: specific, actionable task title
+   - `description`: detailed description of what to implement
+   - `step_type`: 'research', 'design', 'implement', 'test', 'verify', or 'document'
+   - `acceptance_criteria`: list of concrete conditions for completion
+   - `target_files`: file paths that will be created or modified
+   - `code_context`: relevant existing code snippets or patterns (from codebase exploration)
+   - `estimated_effort`: 'low', 'medium', or 'high'
+   - `dependencies`: IDs of other steps this depends on (use step IDs from sibling steps created in this batch)
+
+## Guidelines
+
+- Each child step should be a single, focused task (1-4 hours of work)
+- Include acceptance criteria for every implementation step
+- Reference actual file paths from the codebase when possible
+- Set dependencies between steps where order matters
+- Include at least one test step and one verification step per epic
+- Use verification_strategy with method: 'build', 'test', 'grep_check', 'file_exists', or 'manual_review'
+- ALWAYS set `parent_step_id` to the epic's step ID — steps without a parent appear as top-level epics

package/.claude/skills/find-duplicate-issues/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: find-duplicate-issues
+description: Analyze all issues for similarity, find duplicates or related issues, and suggest consolidation.
+allowed-tools: mcp__quadcode__list_issues, mcp__quadcode__get_issue, mcp__quadcode__update_issue, mcp__quadcode__add_issue_label, mcp__quadcode__add_issue_comment, mcp__quadcode__close_issue, mcp__quadcode__delete_issue
+user-invocable: true
+argument-hint: [threshold]
+---
+
+# Find Duplicate Issues Skill
+
+Analyze all QuadCode issues to find duplicates and similar issues, then suggest consolidation actions.
+
+## Process
+
+1. **Retrieve all issues** using `mcp__quadcode__list_issues`
+
+2. **Analyze similarity** between issues by comparing:
+   - Title keywords and phrases
+   - Body/description content
+   - Labels assigned
+   - Underlying intent/goal
+   - Technical scope
+
+3. **Group similar issues** into clusters:
+   - **Exact duplicates**: Same issue reported differently
+   - **Related issues**: Could be combined or linked
+   - **Overlapping scope**: Partial overlap, may benefit from referencing each other
+
+4. **For each group, determine**:
+   - Which issue should be the primary (most comprehensive, detailed, or oldest)
+   - What unique aspects each duplicate adds
+   - Recommended action: merge, close as duplicate, or link
+
+5. **Report findings** in this format:
+
+```
+## Duplicate Issues Analysis
+
+### Summary
+- Total issues analyzed: X
+- Duplicate groups found: X
+- Issues that could be consolidated: X
+
+### Duplicate Groups
+
+#### Group 1: [Theme/Topic]
+**Primary Issue**: #[ID] - "[title]"
+- Status: [status] | Priority: [priority]
+
+**Potential Duplicates**:
+- #[ID] - "[title]" (similarity: high)
+  - Unique info: [any unique details this adds]
+- #[ID] - "[title]" (similarity: medium)
+  - Unique info: [any unique details]
+
+**Recommendation**: Close [IDs] as duplicates of #[primary], adding comments
+
+[Repeat for each group]
+
+### Related But Distinct
+[Issues that are related but should remain separate, with notes on how they differ]
+```
+
+6. **Ask user for approval** before taking action
+
+7. **Consolidate duplicates** (with user approval):
+   - Add comment to duplicate issues noting the primary issue
+   - Add `duplicate` label to duplicates
+   - Close duplicates with reference to primary
+   - Optionally merge unique content into primary issue body
+
+## Similarity Threshold
+
+If threshold argument is provided ($ARGUMENTS):
+- `strict` - Only exact/near-exact duplicates (same problem reported twice)
+- `moderate` - Include clearly related issues (default)
+- `loose` - Include any topically similar issues
+
+## Actions Available
+
+- `close_issue` - Close a duplicate issue
+- `add_issue_comment` - Add note about duplicate
+- `add_issue_label` - Add 'duplicate' label
+- `update_issue` - Update primary issue with merged content
+
+## Notes
+
+- Always preserve unique information when consolidating
+- Add comments explaining why issues are being closed as duplicates
+- Consider that similar issues may have different root causes
+- When in doubt, add comments linking issues rather than closing

package/.claude/skills/find-duplicates/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: find-duplicates
+description: Analyze all ideas for similarity, group duplicate or related ideas, and suggest merging them.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__merge_ideas, mcp__quadcode__add_tag
+user-invocable: true
+argument-hint: [threshold]
+---
+
+# Find Duplicates Skill
+
+Analyze all QuadCode ideas to find duplicates and similar ideas, then suggest or perform merges.
+
+## Process
+
+1. **Retrieve all ideas** using `mcp__quadcode__list_ideas`
+
+2. **Analyze similarity** between ideas by comparing:
+   - Keywords and phrases in content
+   - Category tags
+   - Underlying intent/goal
+   - Technical scope
+
+3. **Group similar ideas** into clusters:
+   - **Exact duplicates**: Same idea worded differently
+   - **Related ideas**: Could be combined into one comprehensive idea
+   - **Overlapping ideas**: Partial overlap, may benefit from linking
+
+4. **For each group, determine**:
+   - Which idea should be the primary (most comprehensive or clear)
+   - What unique aspects each duplicate adds
+   - Recommended action (merge, link, or keep separate)
+
+5. **Report findings** in this format:
+
+```
+## Duplicate Analysis Report
+
+### Summary
+- Total ideas analyzed: X
+- Duplicate groups found: X
+- Ideas that could be merged: X
+
+### Duplicate Groups
+
+#### Group 1: [Theme/Topic]
+- **Primary**: Idea #X - "[content]"
+- **Duplicates**:
+  - Idea #Y - "[content]" (similarity: high)
+  - Idea #Z - "[content]" (similarity: medium)
+- **Recommendation**: Merge Y and Z into X
+- **Combined content suggestion**: [merged content]
+
+[Repeat for each group]
+
+### Unique Ideas
+[List of ideas with no significant duplicates]
+```
+
+6. **Ask user for approval** before merging
+
+7. **Perform merges** using `mcp__quadcode__merge_ideas`:
+   - Pass primary idea ID and list of IDs to merge
+   - Add `merged` tag to resulting idea if helpful
+
+## Similarity Threshold
+
+If threshold argument is provided ($ARGUMENTS):
+- `strict` - Only exact/near-exact duplicates
+- `moderate` - Include clearly related ideas (default)
+- `loose` - Include any topically similar ideas
+
+## Notes
+
+- Always preserve unique information when merging
+- Consider that differently worded ideas may serve different use cases
+- When in doubt, suggest linking rather than merging
+- Use `mcp__quadcode__add_tag` to mark related ideas with linking tags