@quadslab.io/discord-mcp 2.0.1 → 2.1.0

package/.claude/skills/find-related-code/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: find-related-code
+description: Search the codebase for files and code related to ideas. Adds notes about existing code to help understand what already exists.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__add_idea_note, Read, Grep, Glob
+user-invocable: true
+argument-hint: [idea-id or "all" or tag-name]
+---
+
+# Find Related Code Skill
+
+Search the codebase to find existing code related to QuadCode ideas.
+
+## Process
+
+1. **Determine which ideas to analyze**:
+   - If idea ID provided ($ARGUMENTS as number): Analyze that specific idea
+   - If `all` provided: Analyze all non-implemented ideas
+   - If tag provided: Analyze ideas with that tag
+   - If no argument: Analyze all pending ideas
+
+2. **For each idea**:
+
+   ### Extract Search Terms
+   - Key nouns and technical terms from the idea
+   - Related concepts (e.g., "dark mode" → theme, colors, CSS)
+   - Feature names that might exist
+   - File types likely involved
+
+   ### Search Codebase
+   Use `Grep` and `Glob` to find:
+   - Files with relevant names
+   - Code containing relevant keywords
+   - Similar functionality already implemented
+   - Related configuration or constants
+   - Tests that might indicate features
+
+   ### Analyze Findings
+   For each relevant file found:
+   - What does it do?
+   - How does it relate to the idea?
+   - Could it be extended vs rewritten?
+   - What patterns does it follow?
+
+3. **Categorize findings**:
+   - **Direct match**: Code that implements part of the idea
+   - **Building block**: Code that could be used/extended
+   - **Pattern example**: Similar feature to learn from
+   - **Conflict**: Code that might need refactoring
+   - **Test coverage**: Existing tests to update
+
+4. **Add notes to ideas** using `mcp__quadcode__add_idea_note`:
+   - Set `author` to `"find-related-code"`
+   - Include file paths with line numbers
+   - Note specific functions or classes
+   - Suggest integration approach
+
+   Example:
+   ```
+   mcp__quadcode__add_idea_note({
+     idea_id: "...",
+     body: "Related code found:\n- src/lib/database.ts:45-80 - existing CRUD pattern\n- src/stores/ideaStore.ts - state management\n\nCould extend the existing pattern.",
+     author: "find-related-code"
+   })
+   ```
+
+5. **Generate report**:
+
+```
+## Related Code Analysis
+
+### Idea #X: [Brief content]
+
+#### Direct Matches
+| File | Relevance | Notes |
+|------|-----------|-------|
+| `src/path/file.ts` | High | [What it does] |
+
+#### Building Blocks
+| File | Can Provide | Usage |
+|------|-------------|-------|
+| `src/utils/helper.ts` | [Functionality] | [How to use] |
+
+#### Patterns to Follow
+| File | Pattern | Applicable Because |
+|------|---------|-------------------|
+| `src/features/similar.ts` | [Pattern name] | [Why relevant] |
+
+#### Potential Conflicts
+| File | Issue | Resolution |
+|------|-------|------------|
+| `src/old/legacy.ts` | [Conflict] | [Suggestion] |
+
+#### Implementation Suggestions
+Based on existing code:
+1. Start with `[file]` as a template
+2. Use `[utility]` for [purpose]
+3. Follow the pattern in `[example]`
+4. Update tests in `[test file]`
+
+#### Key Code Snippets
+
+```typescript
+// From src/path/file.ts - relevant function
+[code snippet]
+```
+
+---
+
+[Repeat for each idea analyzed]
+
+---
+
+### Summary
+
+| Idea | Related Files | Ready to Implement | Needs Refactoring |
+|------|---------------|-------------------|-------------------|
+| #1   | 5             | Yes               | No                |
+| #2   | 2             | Partial           | Yes               |
+
+### Codebase Insights
+- Common patterns used: [list]
+- Suggested starting points: [files]
+- Areas needing cleanup first: [files]
+```
+
+## Search Strategies
+
+The skill uses multiple search approaches:
+- **Keyword search**: Direct terms from the idea
+- **Fuzzy matching**: Related concepts
+- **File structure**: Logical locations based on idea type
+- **Import tracing**: What uses related code
+
+## Notes vs Suggestions
+
+- Use **notes** (`add_idea_note`) for code references, findings, and observations
+- Use **suggestions** (`add_suggestion`) only for text/wording improvements to the idea itself
+
+## Notes
+
+- Focus on actionable findings
+- Include enough context to be useful
+- Note code quality concerns if relevant
+- Suggest incremental approaches when possible
+- Identify quick wins vs major refactors

package/.claude/skills/idea-summary/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: idea-summary
+description: Get a quick summary of all ideas organized by category, priority, and status. Perfect for a quick overview of the ideas backlog.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__organize_ideas
+user-invocable: true
+argument-hint: [format]
+---
+
+# Idea Summary Skill
+
+Generate a concise summary of all ideas in QuadCode.
+
+## Process
+
+1. **Retrieve all ideas** using `mcp__quadcode__organize_ideas` for a formatted view
+
+2. **Group ideas by**:
+   - Category (from tags)
+   - Status (implemented, in-progress, pending)
+   - Priority (if tagged)
+
+3. **Generate summary** in the requested format:
+
+### Default Format
+```
+## QuadCode Ideas Summary
+
+Total Ideas: X
+
+### By Category
+- UI/Window: X ideas
+- MCP Integration: X ideas
+- Claude AI: X ideas
+...
+
+### By Status
+- Implemented: X
+- In Progress: X
+- Pending: X
+
+### Recent Ideas (last 5)
+1. [idea content...]
+2. [idea content...]
+...
+
+### High Priority
+- [list high priority ideas]
+```
+
+### Compact Format (use if $ARGUMENTS = "compact")
+Single-line category counts only.
+
+### Detailed Format (use if $ARGUMENTS = "detailed")
+Full content of each idea grouped by category.
+
+### Kanban Format (use if $ARGUMENTS = "kanban")
+Ideas grouped by status columns (Pending | In Progress | Done).

package/.claude/skills/idea-to-prompt/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: idea-to-prompt
+description: Convert an idea into a detailed implementation prompt and begin working on it. Takes an idea ID or lets user select one.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__add_tag, mcp__quadcode__add_idea_note, Read, Write, Edit, Grep, Glob, Bash
+user-invocable: true
+argument-hint: [idea-id]
+---
+
+# Idea to Prompt Skill
+
+Convert a QuadCode idea into a detailed implementation prompt and begin working on it.
+
+## Process
+
+1. **Get the idea**:
+   - If an idea ID is provided ($ARGUMENTS), use `mcp__quadcode__get_idea` to retrieve it
+   - If no ID provided, use `mcp__quadcode__list_ideas` and ask user to select one
+
+2. **Analyze the idea** thoroughly:
+   - Understand the core requirement
+   - Identify technical components needed
+   - Consider dependencies and prerequisites
+   - Note any ambiguities that need clarification
+
+3. **Generate a detailed implementation prompt** that includes:
+   - **Objective**: Clear statement of what needs to be built
+   - **Context**: Why this feature is needed, what problem it solves
+   - **Requirements**: Specific functional requirements
+   - **Technical Approach**: Suggested implementation strategy
+   - **Files to Modify/Create**: Based on codebase analysis
+   - **Acceptance Criteria**: How to know when it's done
+   - **Potential Challenges**: Known risks or complexities
+
+4. **Present the prompt** to the user for confirmation
+
+5. **Begin implementation** once confirmed:
+   - Search codebase for related files using `Grep` and `Glob`
+   - Read relevant existing code using `Read`
+   - Make necessary changes using `Edit` or `Write`
+   - Test changes if possible
+
+6. **Update the idea**:
+   - Add `in-progress` tag using `mcp__quadcode__add_tag`
+   - Add implementation notes using `mcp__quadcode__add_idea_note`:
+     - Set `author` to `"idea-to-prompt"`
+     - Include files modified, progress made, any blockers
+
+   Example:
+   ```
+   mcp__quadcode__add_idea_note({
+     idea_id: "...",
+     body: "Implementation started.\n\nFiles modified:\n- src/lib/database.ts\n- src/types/index.ts\n\nProgress: Basic structure in place.\nNext: Add UI components.",
+     author: "idea-to-prompt"
+   })
+   ```
+
+## Output Format
+
+```
+## Implementation Prompt for Idea #[ID]
+
+### Objective
+[Clear, actionable objective]
+
+### Context
+[Background and motivation]
+
+### Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+...
+
+### Technical Approach
+[Suggested implementation strategy]
+
+### Files Involved
+- `path/to/file1.ts` - [what to modify]
+- `path/to/file2.ts` - [what to modify]
+
+### Acceptance Criteria
+- [ ] Criteria 1
+- [ ] Criteria 2
+
+### Estimated Complexity
+[Low/Medium/High] - [reasoning]
+```
+
+## Notes vs Suggestions
+
+- **Notes** (`add_idea_note`): Implementation progress, file changes, blockers
+- **Suggestions** (`add_suggestion`): Only for text/wording improvements to the idea itself
+
+## Notes
+
+- Always search the codebase first to understand existing patterns
+- Follow existing code style and conventions
+- Ask for clarification if the idea is ambiguous
+- Break large implementations into smaller steps

package/.claude/skills/ideas-maintenance/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: ideas-maintenance
+description: Complete ideas maintenance - organize, tag, check implementation status, and suggest improvements. One button to do everything.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__organize_ideas, mcp__quadcode__add_tag, mcp__quadcode__remove_tag, mcp__quadcode__add_suggestion, mcp__quadcode__add_idea_note, mcp__quadcode__update_idea, mcp__quadcode__get_idea, Read, Grep, Glob, Bash
+user-invocable: true
+---
+
+# Complete Ideas Maintenance Skill
+
+This skill performs comprehensive maintenance on all QuadCode ideas in one operation.
+
+## Full Maintenance Process
+
+### Phase 1: Gather Data
+1. Use `mcp__quadcode__list_ideas` to get all ideas
+2. Note current tags, suggestions, and notes on each idea
+
+### Phase 2: Categorize & Tag
+Apply category tags to untagged ideas:
+- `ui-window` - Window/layout management
+- `ui-appearance` - Themes, fonts, styling
+- `terminal` - Terminal/session management
+- `ideas-tool` - Ideas module improvements
+- `scripts-tool` - Scripts module improvements
+- `mcp` - MCP integration features
+- `streaming` - Streaming/YouTube features
+- `claude-ai` - AI/Claude integration
+- `dev-tools` - Developer tools
+- `misc` - Miscellaneous
+
+### Phase 3: Check Implementation Status
+For each idea, search the codebase:
+1. Use `Grep` to search for keywords from the idea
+2. Use `Glob` to find potentially related files
+3. If implemented, add `implemented` tag
+4. If partial, add `in-progress` tag
+5. **Add implementation notes** using `mcp__quadcode__add_idea_note`:
+   - Set `author` to `"ideas-maintenance"`
+   - Note file paths and relevant code locations
+
+### Phase 4: Suggest Text Improvements
+For ideas that need **wording** improvements (NOT implementation notes):
+1. Vague ideas -> add `expand` suggestion
+2. Unclear ideas -> add `clarify` suggestion
+3. Verbose ideas -> add `summarize` suggestion
+4. Casual wording -> add `reword` suggestion
+
+**Important**: Suggestions are for text/wording improvements only. Use notes for implementation status.
+
+### Phase 5: Generate Report
+
+```markdown
+# Ideas Maintenance Report
+
+## Summary
+- Total ideas: X
+- Newly tagged: X
+- Implementation checked: X
+- Suggestions added: X
+- Notes added: X
+
+## By Category
+| Category | Count | Implemented | Pending |
+|----------|-------|-------------|---------|
+| ui-window | X | X | X |
+| mcp | X | X | X |
+...
+
+## By Status
+- Implemented: X (list)
+- In Progress: X (list)
+- Not Started: X (list)
+
+## Text Suggestions Added
+- Reword: X
+- Expand: X
+- Clarify: X
+- Summarize: X
+
+## Implementation Notes Added
+- Ideas with new code references: X
+
+## Action Items
+1. [high priority items]
+2. [quick wins]
+3. [needs clarification from user]
+```
+
+## Notes vs Suggestions
+
+- **Notes** (`add_idea_note`): Implementation status, code references, observations
+- **Suggestions** (`add_suggestion`): Text/wording improvements to the idea content
+
+## Notes
+- This skill may take longer due to comprehensive checks
+- Safe to run multiple times - won't duplicate tags
+- Suggestions are additive - previous suggestions preserved
+- Notes are additive - previous notes preserved

package/.claude/skills/ideas-to-issues/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: ideas-to-issues
+description: Convert QuadCode ideas to GitHub issues using the gh CLI. Adds appropriate labels and can optionally archive the idea after creation.
+allowed-tools: mcp__quadcode__list_ideas, mcp__quadcode__get_idea, mcp__quadcode__add_tag, mcp__quadcode__archive_idea, Bash
+user-invocable: true
+argument-hint: [idea-id or "all" or "tagged:tag-name"]
+---
+
+# Ideas to Issues Skill
+
+Convert QuadCode ideas into GitHub issues for better project tracking.
+
+## Process
+
+1. **Determine which ideas to convert**:
+   - If specific idea ID provided ($ARGUMENTS): Convert that idea
+   - If `all` provided: Convert all non-archived ideas
+   - If `tagged:tag-name` provided: Convert ideas with that tag
+   - If no argument: List ideas and ask user to select
+
+2. **For each idea, gather information** using `mcp__quadcode__get_idea`:
+   - Idea content
+   - Tags
+   - Suggestions/notes
+   - Creation date
+
+3. **Map tags to GitHub labels**:
+   - `ui-window` → `ui`, `enhancement`
+   - `ui-appearance` → `ui`, `enhancement`
+   - `terminal` → `terminal`, `enhancement`
+   - `mcp` → `mcp`, `enhancement`
+   - `claude-ai` → `ai`, `enhancement`
+   - `dev-tools` → `developer-experience`
+   - `complexity-low` → `good-first-issue`
+   - `complexity-high` → `help-wanted`
+   - `high-priority` → `priority-high`
+   - `bug` → `bug`
+
+4. **Create GitHub issue** using `gh` CLI:
+
+```bash
+gh issue create --title "[Title from idea]" --body "[Formatted body]" --label "[labels]"
+```
+
+Issue body format:
+```markdown
+## Description
+[Idea content]
+
+## Context
+- **Source**: QuadCode Ideas #[ID]
+- **Created**: [date]
+- **Tags**: [tags]
+
+## Additional Notes
+[Any suggestions or notes from the idea]
+
+## Acceptance Criteria
+- [ ] [Derived from idea content]
+
+---
+*Converted from QuadCode Ideas*
+```
+
+5. **After successful creation**:
+   - Add `converted-to-issue` tag using `mcp__quadcode__add_tag`
+   - If user requested, archive the idea using `mcp__quadcode__archive_idea`
+   - Record the issue number/URL
+
+6. **Generate report**:
+
+```
+## Ideas to Issues Conversion Report
+
+### Successfully Created
+| Idea ID | Issue # | Title | Labels |
+|---------|---------|-------|--------|
+| 1       | #42     | ...   | ...    |
+
+### Skipped
+| Idea ID | Reason |
+|---------|--------|
+| 2       | Already has converted-to-issue tag |
+
+### Summary
+- Ideas processed: X
+- Issues created: X
+- Ideas archived: X
+```
+
+## Options
+
+Additional flags in $ARGUMENTS:
+- `--archive` or `-a`: Archive ideas after converting
+- `--dry-run` or `-d`: Show what would be created without actually creating
+- `--milestone=NAME`: Assign to a specific milestone
+
+## Prerequisites
+
+- `gh` CLI must be installed and authenticated
+- Repository must be initialized with GitHub remote
+
+## Notes
+
+- Check for existing `converted-to-issue` tag to avoid duplicates
+- Verify gh authentication before batch operations
+- Allow user to edit issue before creation if interactive
+- Handle rate limits for bulk conversions

package/.claude/skills/issue-summary/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: issue-summary
+description: Get a quick summary of all issues organized by status, priority, and labels. Perfect for a quick overview of the issues backlog.
+allowed-tools: mcp__quadcode__list_issues, mcp__quadcode__list_issues_filtered, mcp__quadcode__organize_issues
+user-invocable: true
+---
+
+# Issue Summary Skill
+
+Provide a quick, organized summary of all issues in QuadCode.
+
+## Process
+
+1. **Get all issues** using `mcp__quadcode__list_issues`
+
+2. **Generate a formatted summary** with:
+
+   ### By Status
+   - In Progress: [count] issues
+   - Blocked: [count] issues (highlight these!)
+   - Todo: [count] issues
+   - Backlog: [count] issues
+   - Done: [count] issues
+
+   ### By Priority
+   - Critical: [count] issues (list titles if any)
+   - High: [count] issues
+   - Medium: [count] issues
+   - Low: [count] issues
+
+   ### By State
+   - Open: [count] issues
+   - Closed: [count] issues
+
+   ### Issues Needing Attention
+   - List any issues with no labels
+   - List any critical/high priority issues that are blocked
+   - List any issues older than 30 days still in backlog
+
+3. **Format output** as a clean markdown summary suitable for quick scanning
+
+## Output Format
+
+```
+## QuadCode Issues Summary
+
+**Total Open Issues:** X
+**Total Closed Issues:** X
+
+### By Status
+- In Progress: X
+- Blocked: X (!)
+- Todo: X
+- Backlog: X
+
+### By Priority
+- Critical: X
+- High: X
+- Medium: X
+- Low: X
+
+### Attention Needed
+- [List any urgent items]
+```

package/.claude/skills/issue-to-prompt/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: issue-to-prompt
+description: Convert an issue into an implementation prompt and autonomously work it to completion. Takes an issue ID or lets user select one. Works without asking for confirmation and automatically moves to QA when done.
+allowed-tools: mcp__quadcode__list_issues, mcp__quadcode__get_issue, mcp__quadcode__update_issue, mcp__quadcode__add_issue_label, mcp__quadcode__add_issue_comment, Read, Write, Edit, Grep, Glob, Bash
+user-invocable: true
+argument-hint: [issue-id]
+---
+
+# Issue to Prompt Skill
+
+Convert a QuadCode issue into a detailed implementation prompt and begin working on it.
+
+## Process
+
+1. **Get the issue**:
+   - If an issue ID is provided ($ARGUMENTS), use `mcp__quadcode__get_issue` to retrieve it
+   - If no ID provided, use `mcp__quadcode__list_issues` to show open issues and ask user to select one
+
+2. **Update issue status**:
+   - Set status to `in_progress` using `mcp__quadcode__update_issue`
+   - Add `working` label using `mcp__quadcode__add_issue_label`
+
+3. **Analyze the issue** thoroughly:
+   - Understand the core requirement from title and body
+   - Identify technical components needed
+   - Consider dependencies and prerequisites
+   - Note the priority level for urgency context
+   - Check existing labels for context
+
+4. **Search the codebase** for context:
+   - Use `Grep` to find related code patterns
+   - Use `Glob` to locate relevant files
+   - Use `Read` to understand existing implementations
+
+5. **Generate a detailed implementation prompt** that includes:
+   - **Objective**: Clear statement of what needs to be done
+   - **Context**: Background from the issue body, why this matters
+   - **Requirements**: Specific functional requirements extracted from the issue
+   - **Technical Approach**: Suggested implementation strategy based on codebase analysis
+   - **Files to Modify/Create**: Identified from codebase search
+   - **Acceptance Criteria**: How to verify the issue is resolved
+   - **Priority Context**: How urgent based on issue priority
+
+6. **Begin implementation immediately** (do not ask for confirmation):
+   - Make necessary changes using `Edit` or `Write`
+   - Follow existing code patterns and conventions
+   - Test changes if possible
+
+7. **Update issue with progress**:
+   - Add implementation comments using `mcp__quadcode__add_issue_comment`
+   - Note files modified and approach taken
+
+## Output Format
+
+```
+## Implementation Plan for Issue #[ID]
+
+**Title**: [issue title]
+**Priority**: [priority] | **Status**: in_progress
+
+### Objective
+[Clear, actionable objective derived from issue]
+
+### Context
+[Background from issue body and codebase analysis]
+
+### Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+...
+
+### Technical Approach
+[Suggested implementation strategy]
+
+### Files Involved
+- `path/to/file1.ts` - [what to modify]
+- `path/to/file2.ts` - [what to create/modify]
+
+### Acceptance Criteria
+- [ ] Issue requirements met
+- [ ] No regressions introduced
+- [ ] Code follows existing patterns
+```
+
+## After Implementation
+
+Once work is complete:
+1. Add final comment to issue summarizing what was done and what should be verified
+2. Automatically set status to `qa` using `mcp__quadcode__update_issue` (do not ask — agents should not set `done`, that's for manual human review)
+
+## Notes
+
+- Always search the codebase first to understand existing patterns
+- Follow existing code style and conventions
+- Work autonomously without asking for confirmation — just implement the issue
+- Break large implementations into smaller steps
+- Keep the issue updated with progress comments
+- Automatically move to QA when done — do not ask for verification