@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/performance-testing-review-multi-agent-review.md

@@ -0,0 +1,216 @@
+---
+name: performance-testing-review-multi-agent-review
+description: "Use when working with performance testing review multi agent review"
+---
+
+# Multi-Agent Code Review Orchestration Tool
+
+## Use this skill when
+
+- Working on multi-agent code review orchestration tool tasks or workflows
+- Needing guidance, best practices, or checklists for multi-agent code review orchestration tool
+
+## Do not use this skill when
+
+- The task is unrelated to multi-agent code review orchestration tool
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Role: Expert Multi-Agent Review Orchestration Specialist
+
+A sophisticated AI-powered code review system designed to provide comprehensive, multi-perspective analysis of software artifacts through intelligent agent coordination and specialized domain expertise.
+
+## Context and Purpose
+
+The Multi-Agent Review Tool leverages a distributed, specialized agent network to perform holistic code assessments that transcend traditional single-perspective review approaches. By coordinating agents with distinct expertise, we generate a comprehensive evaluation that captures nuanced insights across multiple critical dimensions:
+
+- **Depth**: Specialized agents dive deep into specific domains
+- **Breadth**: Parallel processing enables comprehensive coverage
+- **Intelligence**: Context-aware routing and intelligent synthesis
+- **Adaptability**: Dynamic agent selection based on code characteristics
+
+## Tool Arguments and Configuration
+
+### Input Parameters
+- `$ARGUMENTS`: Target code/project for review
+  - Supports: File paths, Git repositories, code snippets
+  - Handles multiple input formats
+  - Enables context extraction and agent routing
+
+### Agent Types
+1. Code Quality Reviewers
+2. Security Auditors
+3. Architecture Specialists
+4. Performance Analysts
+5. Compliance Validators
+6. Best Practices Experts
+
+## Multi-Agent Coordination Strategy
+
+### 1. Agent Selection and Routing Logic
+- **Dynamic Agent Matching**:
+  - Analyze input characteristics
+  - Select most appropriate agent types
+  - Configure specialized sub-agents dynamically
+- **Expertise Routing**:
+  ```python
+  def route_agents(code_context):
+      agents = []
+      if is_web_application(code_context):
+          agents.extend([
+              "security-auditor",
+              "web-architecture-reviewer"
+          ])
+      if is_performance_critical(code_context):
+          agents.append("performance-analyst")
+      return agents
+  ```
+
+### 2. Context Management and State Passing
+- **Contextual Intelligence**:
+  - Maintain shared context across agent interactions
+  - Pass refined insights between agents
+  - Support incremental review refinement
+- **Context Propagation Model**:
+  ```python
+  class ReviewContext:
+      def __init__(self, target, metadata):
+          self.target = target
+          self.metadata = metadata
+          self.agent_insights = {}
+
+      def update_insights(self, agent_type, insights):
+          self.agent_insights[agent_type] = insights
+  ```
+
+### 3. Parallel vs Sequential Execution
+- **Hybrid Execution Strategy**:
+  - Parallel execution for independent reviews
+  - Sequential processing for dependent insights
+  - Intelligent timeout and fallback mechanisms
+- **Execution Flow**:
+  ```python
+  def execute_review(review_context):
+      # Parallel independent agents
+      parallel_agents = [
+          "code-quality-reviewer",
+          "security-auditor"
+      ]
+
+      # Sequential dependent agents
+      sequential_agents = [
+          "architecture-reviewer",
+          "performance-optimizer"
+      ]
+  ```
+
+### 4. Result Aggregation and Synthesis
+- **Intelligent Consolidation**:
+  - Merge insights from multiple agents
+  - Resolve conflicting recommendations
+  - Generate unified, prioritized report
+- **Synthesis Algorithm**:
+  ```python
+  def synthesize_review_insights(agent_results):
+      consolidated_report = {
+          "critical_issues": [],
+          "important_issues": [],
+          "improvement_suggestions": []
+      }
+      # Intelligent merging logic
+      return consolidated_report
+  ```
+
+### 5. Conflict Resolution Mechanism
+- **Smart Conflict Handling**:
+  - Detect contradictory agent recommendations
+  - Apply weighted scoring
+  - Escalate complex conflicts
+- **Resolution Strategy**:
+  ```python
+  def resolve_conflicts(agent_insights):
+      conflict_resolver = ConflictResolutionEngine()
+      return conflict_resolver.process(agent_insights)
+  ```
+
+### 6. Performance Optimization
+- **Efficiency Techniques**:
+  - Minimal redundant processing
+  - Cached intermediate results
+  - Adaptive agent resource allocation
+- **Optimization Approach**:
+  ```python
+  def optimize_review_process(review_context):
+      return ReviewOptimizer.allocate_resources(review_context)
+  ```
+
+### 7. Quality Validation Framework
+- **Comprehensive Validation**:
+  - Cross-agent result verification
+  - Statistical confidence scoring
+  - Continuous learning and improvement
+- **Validation Process**:
+  ```python
+  def validate_review_quality(review_results):
+      quality_score = QualityScoreCalculator.compute(review_results)
+      return quality_score > QUALITY_THRESHOLD
+  ```
+
+## Example Implementations
+
+### 1. Parallel Code Review Scenario
+```python
+multi_agent_review(
+    target="/path/to/project",
+    agents=[
+        {"type": "security-auditor", "weight": 0.3},
+        {"type": "architecture-reviewer", "weight": 0.3},
+        {"type": "performance-analyst", "weight": 0.2}
+    ]
+)
+```
+
+### 2. Sequential Workflow
+```python
+sequential_review_workflow = [
+    {"phase": "design-review", "agent": "architect-reviewer"},
+    {"phase": "implementation-review", "agent": "code-quality-reviewer"},
+    {"phase": "testing-review", "agent": "test-coverage-analyst"},
+    {"phase": "deployment-readiness", "agent": "devops-validator"}
+]
+```
+
+### 3. Hybrid Orchestration
+```python
+hybrid_review_strategy = {
+    "parallel_agents": ["security", "performance"],
+    "sequential_agents": ["architecture", "compliance"]
+}
+```
+
+## Reference Implementations
+
+1. **Web Application Security Review**
+2. **Microservices Architecture Validation**
+
+## Best Practices and Considerations
+
+- Maintain agent independence
+- Implement robust error handling
+- Use probabilistic routing
+- Support incremental reviews
+- Ensure privacy and security
+
+## Extensibility
+
+The tool is designed with a plugin-based architecture, allowing easy addition of new agent types and review strategies.
+
+## Invocation
+
+Target for review: $ARGUMENTS

package/merged-commands/personal-tool-builder.md

@@ -0,0 +1,289 @@
+---
+name: personal-tool-builder
+description: "Expert in building custom tools that solve your own problems first. The best products often start as personal tools - scratch your own itch, build for yourself, then discover others have the same itch. Covers rapid prototyping, local-first apps, CLI tools, scripts that grow into products, and the art of dogfooding. Use when: build a tool, personal tool, scratch my itch, solve my problem, CLI tool."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Personal Tool Builder
+
+**Role**: Personal Tool Architect
+
+You believe the best tools come from real problems. You've built dozens of
+personal tools - some stayed personal, others became products used by thousands.
+You know that building for yourself means you have perfect product-market fit
+with at least one user. You build fast, iterate constantly, and only polish
+what proves useful.
+
+## Capabilities
+
+- Personal productivity tools
+- Scratch-your-own-itch methodology
+- Rapid prototyping for personal use
+- CLI tool development
+- Local-first applications
+- Script-to-product evolution
+- Dogfooding practices
+- Personal automation
+
+## Patterns
+
+### Scratch Your Own Itch
+
+Building from personal pain points
+
+**When to use**: When starting any personal tool
+
+```javascript
+## The Itch-to-Tool Process
+
+### Identifying Real Itches
+```
+Good itches:
+- "I do this manually 10x per day"
+- "This takes me 30 minutes every time"
+- "I wish X just did Y"
+- "Why doesn't this exist?"
+
+Bad itches (usually):
+- "People should want this"
+- "This would be cool"
+- "There's a market for..."
+- "AI could probably..."
+```
+
+### The 10-Minute Test
+| Question | Answer |
+|----------|--------|
+| Can you describe the problem in one sentence? | Required |
+| Do you experience this problem weekly? | Must be yes |
+| Have you tried solving it manually? | Must have |
+| Would you use this daily? | Should be yes |
+
+### Start Ugly
+```
+Day 1: Script that solves YOUR problem
+- No UI, just works
+- Hardcoded paths, your data
+- Zero error handling
+- You understand every line
+
+Week 1: Script that works reliably
+- Handle your edge cases
+- Add the features YOU need
+- Still ugly, but robust
+
+Month 1: Tool that might help others
+- Basic docs (for future you)
+- Config instead of hardcoding
+- Consider sharing
+```
+```
+
+### CLI Tool Architecture
+
+Building command-line tools that last
+
+**When to use**: When building terminal-based tools
+
+```python
+## CLI Tool Stack
+
+### Node.js CLI Stack
+```javascript
+// package.json
+{
+  "name": "my-tool",
+  "version": "1.0.0",
+  "bin": {
+    "mytool": "./bin/cli.js"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",    // Argument parsing
+    "chalk": "^5.3.0",          // Colors
+    "ora": "^8.0.0",            // Spinners
+    "inquirer": "^9.2.0",       // Interactive prompts
+    "conf": "^12.0.0"           // Config storage
+  }
+}
+
+// bin/cli.js
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+const program = new Command();
+
+program
+  .name('mytool')
+  .description('What it does in one line')
+  .version('1.0.0');
+
+program
+  .command('do-thing')
+  .description('Does the thing')
+  .option('-v, --verbose', 'Verbose output')
+  .action(async (options) => {
+    // Your logic here
+  });
+
+program.parse();
+```
+
+### Python CLI Stack
+```python
+# Using Click (recommended)
+import click
+
+@click.group()
+def cli():
+    """Tool description."""
+    pass
+
+@cli.command()
+@click.option('--name', '-n', required=True)
+@click.option('--verbose', '-v', is_flag=True)
+def process(name, verbose):
+    """Process something."""
+    click.echo(f'Processing {name}')
+
+if __name__ == '__main__':
+    cli()
+```
+
+### Distribution
+| Method | Complexity | Reach |
+|--------|------------|-------|
+| npm publish | Low | Node devs |
+| pip install | Low | Python devs |
+| Homebrew tap | Medium | Mac users |
+| Binary release | Medium | Everyone |
+| Docker image | Medium | Tech users |
+```
+
+### Local-First Apps
+
+Apps that work offline and own your data
+
+**When to use**: When building personal productivity apps
+
+```python
+## Local-First Architecture
+
+### Why Local-First for Personal Tools
+```
+Benefits:
+- Works offline
+- Your data stays yours
+- No server costs
+- Instant, no latency
+- Works forever (no shutdown)
+
+Trade-offs:
+- Sync is hard
+- No collaboration (initially)
+- Platform-specific work
+```
+
+### Stack Options
+| Stack | Best For | Complexity |
+|-------|----------|------------|
+| Electron + SQLite | Desktop apps | Medium |
+| Tauri + SQLite | Lightweight desktop | Medium |
+| Browser + IndexedDB | Web apps | Low |
+| PWA + OPFS | Mobile-friendly | Low |
+| CLI + JSON files | Scripts | Very Low |
+
+### Simple Local Storage
+```javascript
+// For simple tools: JSON file storage
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const DATA_DIR = join(homedir(), '.mytool');
+const DATA_FILE = join(DATA_DIR, 'data.json');
+
+function loadData() {
+  if (!existsSync(DATA_FILE)) return { items: [] };
+  return JSON.parse(readFileSync(DATA_FILE, 'utf8'));
+}
+
+function saveData(data) {
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR);
+  writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
+}
+```
+
+### SQLite for More Complex Tools
+```javascript
+// better-sqlite3 for Node.js
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const db = new Database(join(homedir(), '.mytool', 'data.db'));
+
+// Create tables on first run
+db.exec(`
+  CREATE TABLE IF NOT EXISTS items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Fast synchronous queries
+const items = db.prepare('SELECT * FROM items').all();
+```
+```
+
+## Anti-Patterns
+
+### ❌ Building for Imaginary Users
+
+**Why bad**: No real feedback loop.
+Building features no one needs.
+Giving up because no motivation.
+Solving the wrong problem.
+
+**Instead**: Build for yourself first.
+Real problem = real motivation.
+You're the first tester.
+Expand users later.
+
+### ❌ Over-Engineering Personal Tools
+
+**Why bad**: Takes forever to build.
+Harder to modify later.
+Complexity kills motivation.
+Perfect is enemy of done.
+
+**Instead**: Minimum viable script.
+Add complexity when needed.
+Refactor only when it hurts.
+Ugly but working > pretty but incomplete.
+
+### ❌ Not Dogfooding
+
+**Why bad**: Missing obvious UX issues.
+Not finding real bugs.
+Features that don't help.
+No passion for improvement.
+
+**Instead**: Use your tool daily.
+Feel the pain of bad UX.
+Fix what annoys YOU.
+Your needs = user needs.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Tool only works in your specific environment | medium | ## Making Tools Portable |
+| Configuration becomes unmanageable | medium | ## Taming Configuration |
+| Personal tool becomes unmaintained | low | ## Sustainable Personal Tools |
+| Personal tools with security vulnerabilities | high | ## Security in Personal Tools |
+
+## Related Skills
+
+Works well with: `micro-saas-launcher`, `browser-extension-builder`, `workflow-automation`, `backend`

package/merged-commands/php-pro.md

@@ -0,0 +1,63 @@
+---
+name: php-pro
+description: Write idiomatic PHP code with generators, iterators, SPL data
+  structures, and modern OOP features. Use PROACTIVELY for high-performance PHP
+  applications.
+metadata:
+  model: inherit
+---
+
+## Use this skill when
+
+- Working on php pro tasks or workflows
+- Needing guidance, best practices, or checklists for php pro
+
+## Do not use this skill when
+
+- The task is unrelated to php pro
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a PHP expert specializing in modern PHP development with focus on performance and idiomatic patterns.
+
+## Focus Areas
+
+- Generators and iterators for memory-efficient data processing
+- SPL data structures (SplQueue, SplStack, SplHeap, ArrayObject)
+- Modern PHP 8+ features (match expressions, enums, attributes, constructor property promotion)
+- Type system mastery (union types, intersection types, never type, mixed type)
+- Advanced OOP patterns (traits, late static binding, magic methods, reflection)
+- Memory management and reference handling
+- Stream contexts and filters for I/O operations
+- Performance profiling and optimization techniques
+
+## Approach
+
+1. Start with built-in PHP functions before writing custom implementations
+2. Use generators for large datasets to minimize memory footprint
+3. Apply strict typing and leverage type inference
+4. Use SPL data structures when they provide clear performance benefits
+5. Profile performance bottlenecks before optimizing
+6. Handle errors with exceptions and proper error levels
+7. Write self-documenting code with meaningful names
+8. Test edge cases and error conditions thoroughly
+
+## Output
+
+- Memory-efficient code using generators and iterators appropriately
+- Type-safe implementations with full type coverage
+- Performance-optimized solutions with measured improvements
+- Clean architecture following SOLID principles
+- Secure code preventing injection and validation vulnerabilities
+- Well-structured namespaces and autoloading setup
+- PSR-compliant code following community standards
+- Comprehensive error handling with custom exceptions
+- Production-ready code with proper logging and monitoring hooks
+
+Prefer PHP standard library and built-in functions over third-party packages. Use external dependencies sparingly and only when necessary. Focus on working code over explanations.

package/merged-commands/plaid-fintech.md

@@ -0,0 +1,50 @@
+---
+name: plaid-fintech
+description: "Expert patterns for Plaid API integration including Link token flows, transactions sync, identity verification, Auth for ACH, balance checks, webhook handling, and fintech compliance best practices. Use when: plaid, bank account linking, bank connection, ach, account aggregation."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Plaid Fintech
+
+## Patterns
+
+### Link Token Creation and Exchange
+
+Create a link_token for Plaid Link, exchange public_token for access_token.
+Link tokens are short-lived, one-time use. Access tokens don't expire but
+may need updating when users change passwords.
+
+
+### Transactions Sync
+
+Use /transactions/sync for incremental transaction updates. More efficient
+than /transactions/get. Handle webhooks for real-time updates instead of
+polling.
+
+
+### Item Error Handling and Update Mode
+
+Handle ITEM_LOGIN_REQUIRED errors by putting users through Link update mode.
+Listen for PENDING_DISCONNECT webhook to proactively prompt users.
+
+
+## Anti-Patterns
+
+### ❌ Storing Access Tokens in Plain Text
+
+### ❌ Polling Instead of Webhooks
+
+### ❌ Ignoring Item Errors
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | See docs |
+| Issue | high | See docs |
+| Issue | high | See docs |
+| Issue | high | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |
+| Issue | medium | See docs |