@poolzin/plcode 2.1.1 → 3.0.1

package/.plcode/command/review.md

@@ -0,0 +1,14 @@
+---
+description: Request a code review for the current work
+argument-hint: [files]
+---
+
+# Request Code Review
+
+**Focus Area:** $ARGUMENTS
+
+**Instructions:**
+
+1.  **Target:** I need a code quality and spec compliance review for the current changes.
+2.  **Action:** Please **invoke/use the `requesting-code-review` skill** immediately.
+3.  Focus your review on the files/areas specified above (if any).

package/.plcode/command/rmslop.md

@@ -0,0 +1,15 @@
+---
+description: Remove AI code slop
+---
+
+Check the diff against dev, and remove all AI generated slop introduced in this branch.
+
+This includes:
+
+- Extra comments that a human wouldn't add or is inconsistent with the rest of the file
+- Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted / validated codepaths)
+- Casts to any to get around type issues
+- Any other style that is inconsistent with the file
+- Unnecessary emoji usage
+
+Report at the end with only a 1-3 sentence summary of what you changed

package/.plcode/command/seo.md

@@ -0,0 +1,68 @@
+---
+description: Implement SEO optimizations for specified pages or entire site
+argument-hint: Page path or "all" for entire site
+---
+
+# SEO Optimization Command
+
+**Target:** `$ARGUMENTS` (or entire site if not specified)
+
+Please implement comprehensive SEO optimizations for the specified target:
+
+## Technical SEO
+
+- [ ] Add/optimize meta titles and descriptions
+- [ ] Implement structured data (JSON-LD schema markup)
+- [ ] Create/update robots.txt and sitemap.xml
+- [ ] Add Open Graph and Twitter Card meta tags
+- [ ] Optimize canonical URLs
+- [ ] Implement proper heading hierarchy (H1-H6)
+
+## Performance SEO
+
+- [ ] Optimize Core Web Vitals (LCP, FID, CLS)
+- [ ] Implement image lazy loading and optimization
+- [ ] Minimize JavaScript and CSS
+- [ ] Enable compression and caching
+- [ ] Optimize server response times
+
+## Content SEO
+
+- [ ] Optimize content for target keywords
+- [ ] Improve internal linking structure
+- [ ] Add alt text to all images
+- [ ] Ensure mobile responsiveness
+- [ ] Implement proper URL structure
+
+## Accessibility (SEO Impact)
+
+- [ ] WCAG 2.1 AA compliance
+- [ ] Semantic HTML usage
+- [ ] ARIA labels where needed
+- [ ] Keyboard navigation support
+
+## 📚 **DOCUMENTATION REQUIREMENTS**
+
+**Create comprehensive SEO documentation at:**
+
+- `docs/tasks/frontend/DD-MM-YYYY/<semantic-seo-id>/`
+
+**Documentation Structure:**
+
+- `README.md` - SEO audit overview and objectives
+- `technical-seo-audit.md` - Meta tags, structured data, schema markup
+- `performance-analysis.md` - Core Web Vitals, optimization metrics
+- `content-optimization.md` - Keyword analysis, content improvements
+- `accessibility-review.md` - WCAG compliance and SEO impact
+- `implementation-notes.md` - Technical decisions and trade-offs
+- `before-after-comparison.md` - SEO score improvements with metrics
+
+**Semantic SEO Task ID Examples:**
+
+- `homepage-meta-optimization`
+- `product-page-structured-data`
+- `blog-content-seo-enhancement`
+- `core-web-vitals-optimization`
+- `semantic-html-seo-improvement`
+
+Please analyze the current state, implement missing optimizations, and document all changes according to the standards above.

package/.plcode/command/spellcheck.md

@@ -0,0 +1,5 @@
+---
+description: spellcheck all markdown file changes
+---
+
+Look at all the unstaged changes to markdown (.md, .mdx) files, pull out the lines that have changed, and check for spelling and grammar errors.

package/.plcode/command/subagent-driven-development.md

@@ -0,0 +1,14 @@
+---
+description: Execute plan using subagent-driven development
+argument-hint: [plan-file]
+---
+
+# Execute Plan
+
+**User Input:** $ARGUMENTS
+
+**Instructions:**
+
+1.  **Target:** I want to execute the implementation plan specified in "$ARGUMENTS".
+2.  **Action:** Please **invoke/use the `subagent-driven-development` skill** immediately.
+3.  Ensure that the implementation strictly follows **TDD** (Test-Driven Development).

package/.plcode/command/superpowers-brainstorm.md

@@ -0,0 +1,45 @@
+---
+description: "MANDATORY before any creative work - creating features, building components, adding functionality. Explores requirements and design before implementation."
+---
+
+# Superpowers Brainstorm
+
+You MUST use this before any creative work. This is not optional.
+
+## Instructions
+
+1. **Load the brainstorming skill immediately:**
+
+   ```
+   Use the skill tool: skill("brainstorming")
+   ```
+
+2. **Follow the skill exactly as presented**
+
+3. **Key workflow:**
+   - Understand the current project context first
+   - Ask questions ONE AT A TIME to refine the idea
+   - Prefer multiple choice questions when possible
+   - Present design in small sections (200-300 words)
+   - Check after each section if it looks right
+   - Save design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
+
+4. **After design approval:**
+   - Use `skill("using-git-worktrees")` to create isolated workspace
+   - Use `skill("writing-plans")` to create implementation plan
+
+## When to use this
+
+- Before creating any new feature
+- Before building any new component
+- Before adding any new functionality
+- Before modifying existing behavior
+- When requirements are unclear
+- When exploring alternatives
+
+## Key Principles
+
+- One question at a time
+- YAGNI ruthlessly (You Aren't Gonna Need It)
+- Explore 2-3 alternatives before settling
+- Incremental validation of design

package/.plcode/command/superpowers-execute-plan.md

@@ -0,0 +1,49 @@
+---
+description: Execute implementation plan in batches with review checkpoints
+---
+
+# Superpowers Execute Plan
+
+Execute an implementation plan in batches with review checkpoints.
+
+## Instructions
+
+1. **Load the executing-plans skill immediately:**
+
+   ```
+   Use the skill tool: skill("executing-plans")
+   ```
+
+2. **Follow the skill exactly as presented**
+
+3. **Key workflow:**
+   - Execute tasks in small batches (3-5 tasks)
+   - After each batch, review and checkpoint
+   - Use TDD for each task: RED -> GREEN -> REFACTOR
+   - Request code review after major steps
+
+4. **For each task:**
+   - Mark as in_progress in todo list
+   - Follow test-driven-development skill
+   - Verify all criteria pass
+   - Mark as completed
+   - Commit changes
+
+5. **After each batch:**
+   - Run all tests
+   - Review against plan
+   - Ask for human checkpoint if needed
+
+## When to use this
+
+- After plan has been created (from write-plan)
+- When implementing features step by step
+- When working through a task list
+- For autonomous development sessions
+
+## Key Principles
+
+- Small batches with checkpoints
+- TDD for every code change
+- Verify before moving on
+- Commit frequently

package/.plcode/command/superpowers-write-plan.md

@@ -0,0 +1,55 @@
+---
+description: Create detailed implementation plan with bite-sized tasks after design approval
+---
+
+# Superpowers Write Plan
+
+Create a detailed implementation plan with bite-sized tasks.
+
+## Instructions
+
+1. **Load the writing-plans skill immediately:**
+
+   ```
+   Use the skill tool: skill("writing-plans")
+   ```
+
+2. **Follow the skill exactly as presented**
+
+3. **Key workflow:**
+   - Break work into bite-sized tasks (2-5 minutes each)
+   - Every task has exact file paths and complete code
+   - Every task has verification steps
+   - Save plan to `docs/plans/YYYY-MM-DD-<topic>-implementation.md`
+
+4. **Task format:**
+
+   ```markdown
+   ## Task N: [Title]
+
+   **Files:** path/to/file.ts
+
+   **Changes:**
+
+   - Specific change 1
+   - Specific change 2
+
+   **Verification:**
+
+   - [ ] Test X passes
+   - [ ] Behavior Y works
+   ```
+
+## When to use this
+
+- After design has been approved (from brainstorming)
+- Before starting implementation
+- When breaking down complex features
+- When delegating to subagents
+
+## Key Principles
+
+- Tasks should be completable in 2-5 minutes
+- Each task is independent and atomic
+- Clear verification criteria for each task
+- Emphasize TDD (test-driven development)

package/.plcode/command/superpowers.md

@@ -0,0 +1,10 @@
+---
+description: Force the AI to activate the Superpowers skill natively
+---
+
+# Activate Superpowers
+
+**Instructions:**
+
+1.  **Action:** Please **invoke/use using-superpowers skill** immediately.
+2.  **Confirmation:** Once you have activated the skill, confirm that you are running under its protocols.

package/.plcode/command/test-new-command.md

@@ -0,0 +1,27 @@
+---
+description: "Test command to verify auto-detection and registry updates work correctly"
+---
+
+# Test New Command
+
+This is a test command created to verify that the auto-detection system works.
+
+## Usage
+
+```bash
+/test-new-command
+```
+
+## Features
+
+- Auto-detected by the system
+- Automatically added to registry
+- Validates the build system works
+
+## Testing
+
+This file should be:
+
+1. Detected by `auto-detect-components.sh`
+2. Added to registry.json automatically
+3. Validated by `validate-registry.sh`

package/.plcode/command/test.md

@@ -0,0 +1,26 @@
+---
+description: Run the complete testing pipeline
+---
+
+# Testing Pipeline
+
+This command runs the complete testing pipeline for the project.
+
+## Usage
+
+To run the complete testing pipeline, just type:
+
+1. Run pnpm type:check
+2. Run pnpm lint
+3. Run pnpm test
+4. Report any failures
+5. Fix any failures
+6. Repeat until all tests pass
+7. Report success
+
+## What This Command Does
+
+1. Runs `pnpm type:check` to check for type errors
+2. Runs `pnpm lint` to check for linting errors
+3. Runs `pnpm test` to run the tests
+4. Reports any failures

package/.plcode/command/ultra-think.md

@@ -0,0 +1,160 @@
+---
+description: Deep analysis and problem solving mode
+category: utilities-debugging
+argument-hint: "Identify all stakeholders and constraints"
+---
+
+# Deep Analysis and Problem Solving Mode
+
+Deep analysis and problem solving mode
+
+## Instructions
+
+1. **Initialize Ultra Think Mode**
+   - Acknowledge the request for enhanced analytical thinking
+   - Set context for deep, systematic reasoning
+   - Prepare to explore the problem space comprehensively
+
+2. **Parse the Problem or Question**
+   - Extract the core challenge from: **$ARGUMENTS**
+   - Identify all stakeholders and constraints
+   - Recognize implicit requirements and hidden complexities
+   - Question assumptions and surface unknowns
+
+3. **Multi-Dimensional Analysis**
+   Approach the problem from multiple angles:
+
+   ### Technical Perspective
+   - Analyze technical feasibility and constraints
+   - Consider scalability, performance, and maintainability
+   - Evaluate security implications
+   - Assess technical debt and future-proofing
+
+   ### Business Perspective
+   - Understand business value and ROI
+   - Consider time-to-market pressures
+   - Evaluate competitive advantages
+   - Assess risk vs. reward trade-offs
+
+   ### User Perspective
+   - Analyze user needs and pain points
+   - Consider usability and accessibility
+   - Evaluate user experience implications
+   - Think about edge cases and user journeys
+
+   ### System Perspective
+   - Consider system-wide impacts
+   - Analyze integration points
+   - Evaluate dependencies and coupling
+   - Think about emergent behaviors
+
+4. **Generate Multiple Solutions**
+   - Brainstorm at least 3-5 different approaches
+   - For each approach, consider:
+     - Pros and cons
+     - Implementation complexity
+     - Resource requirements
+     - Potential risks
+     - Long-term implications
+   - Include both conventional and creative solutions
+   - Consider hybrid approaches
+
+5. **Deep Dive Analysis**
+   For the most promising solutions:
+   - Create detailed implementation plans
+   - Identify potential pitfalls and mitigation strategies
+   - Consider phased approaches and MVPs
+   - Analyze second and third-order effects
+   - Think through failure modes and recovery
+
+6. **Cross-Domain Thinking**
+   - Draw parallels from other industries or domains
+   - Apply design patterns from different contexts
+   - Consider biological or natural system analogies
+   - Look for innovative combinations of existing solutions
+
+7. **Challenge and Refine**
+   - Play devil's advocate with each solution
+   - Identify weaknesses and blind spots
+   - Consider "what if" scenarios
+   - Stress-test assumptions
+   - Look for unintended consequences
+
+8. **Synthesize Insights**
+   - Combine insights from all perspectives
+   - Identify key decision factors
+   - Highlight critical trade-offs
+   - Summarize innovative discoveries
+   - Present a nuanced view of the problem space
+
+9. **Provide Structured Recommendations**
+   Present findings in a clear structure:
+
+   ```
+   ## Problem Analysis
+   - Core challenge
+   - Key constraints
+   - Critical success factors
+
+   ## Solution Options
+   ### Option 1: [Name]
+   - Description
+   - Pros/Cons
+   - Implementation approach
+   - Risk assessment
+
+   ### Option 2: [Name]
+   [Similar structure]
+
+   ## Recommendation
+   - Recommended approach
+   - Rationale
+   - Implementation roadmap
+   - Success metrics
+   - Risk mitigation plan
+
+   ## Alternative Perspectives
+   - Contrarian view
+   - Future considerations
+   - Areas for further research
+   ```
+
+10. **Meta-Analysis**
+    - Reflect on the thinking process itself
+    - Identify areas of uncertainty
+    - Acknowledge biases or limitations
+    - Suggest additional expertise needed
+    - Provide confidence levels for recommendations
+
+## Usage Examples
+
+```bash
+# Architectural decision
+/project:ultra-think Should we migrate to microservices or improve our monolith?
+
+# Complex problem solving
+/project:ultra-think How do we scale our system to handle 10x traffic while reducing costs?
+
+# Strategic planning
+/project:ultra-think What technology stack should we choose for our next-gen platform?
+
+# Design challenge
+/project:ultra-think How can we improve our API to be more developer-friendly while maintaining backward compatibility?
+```
+
+## Key Principles
+
+- **First Principles Thinking**: Break down to fundamental truths
+- **Systems Thinking**: Consider interconnections and feedback loops
+- **Probabilistic Thinking**: Work with uncertainties and ranges
+- **Inversion**: Consider what to avoid, not just what to do
+- **Second-Order Thinking**: Consider consequences of consequences
+
+## Output Expectations
+
+- Comprehensive analysis (typically 2-4 pages of insights)
+- Multiple viable solutions with trade-offs
+- Clear reasoning chains
+- Acknowledgment of uncertainties
+- Actionable recommendations
+- Novel insights or perspectives