@hienlh/ppm 0.9.81 → 0.9.83

package/.opencode/skills/test/references/test-execution-workflow.md

@@ -1,103 +0,0 @@
-# Test Execution Workflow
-
-## Step 1: Identify Scope
-
-Determine what to test based on recent changes:
-- New feature → full test suite + new test cases
-- Bug fix → regression tests + targeted fix validation
-- Refactor → existing test suite (no new tests unless gaps found)
-- Coverage check → full suite with coverage flags
-
-## Step 2: Pre-flight Checks
-
-Run syntax/type checks before tests to catch compile errors early:
-
-```bash
-# JavaScript/TypeScript
-npx tsc --noEmit          # TypeScript check
-npx eslint .              # Lint check
-
-# Python
-python -m py_compile file.py
-flake8 .
-
-# Flutter
-flutter analyze
-
-# Go
-go vet ./...
-
-# Rust
-cargo check
-```
-
-## Step 3: Execute Tests
-
-### JavaScript/TypeScript
-```bash
-npm test                    # or yarn test / pnpm test / bun test
-npm run test:coverage       # with coverage
-npx vitest run              # Vitest
-npx jest --coverage         # Jest with coverage
-```
-
-### Python
-```bash
-pytest                      # basic
-pytest --cov=src --cov-report=term-missing  # with coverage
-python -m unittest discover # unittest
-```
-
-### Go / Rust / Flutter
-```bash
-go test ./... -cover        # Go with coverage
-cargo test                  # Rust
-flutter test --coverage     # Flutter
-```
-
-## Step 4: Analyze Results
-
-Focus on:
-1. **Failing tests** — read error messages and stack traces carefully
-2. **Flaky tests** — tests that pass/fail intermittently indicate race conditions or state leaks
-3. **Slow tests** — identify bottlenecks (>5s per test is suspicious)
-4. **Skipped tests** — ensure skips are intentional, not hiding failures
-
-## Step 5: Coverage Analysis
-
-Thresholds:
-- **80%+** line coverage — standard minimum
-- **70%+** branch coverage — acceptable for most projects
-- Focus on critical paths: auth, payment, data mutations
-
-Identify gaps:
-- Uncovered error handlers
-- Missing edge case branches
-- Untested utility functions
-
-## Step 6: Build Verification
-
-```bash
-npm run build               # JS/TS production build
-python setup.py build       # Python
-go build ./...              # Go
-cargo build --release       # Rust
-flutter build               # Flutter
-```
-
-Check for:
-- Build warnings or deprecation notices
-- Unresolved dependencies
-- Production config correctness
-
-## Quality Checklist
-
-- [ ] All tests pass (zero failures)
-- [ ] Coverage meets project threshold
-- [ ] No flaky tests detected
-- [ ] Build completes without errors
-- [ ] Error scenarios tested
-- [ ] Test isolation verified (no shared state)
-- [ ] Test data cleaned up after execution
-- [ ] Mocks/stubs properly configured
-- [ ] Environment variables correctly set

package/.opencode/skills/test/references/ui-testing-workflow.md

@@ -1,65 +0,0 @@
-# UI Testing Workflow
-
-Activate the ck:chrome-devtools skill.
-
-## Purpose
-Run comprehensive UI tests on a website and generate a detailed report.
-
-## Arguments
-- $1: URL - The URL of the website to test
-- $2: OPTIONS - Optional test configuration (e.g., --headless, --mobile, --auth)
-
-## Testing Protected Routes (Authentication)
-
-### Step 1: User Manual Login
-Instruct the user to:
-1. Open the target site in their browser
-2. Log in manually with their credentials
-3. Open browser DevTools (F12) → Application tab → Cookies/Storage
-
-### Step 2: Extract Auth Credentials
-Ask the user to provide one of:
-- **Cookies**: Copy cookie values (name, value, domain)
-- **Access Token**: Copy JWT/Bearer token from localStorage or cookies
-- **Session Storage**: Copy relevant session keys
-
-### Step 3: Inject Authentication
-Use the `inject-auth.js` script:
-
-```bash
-cd $SKILL_DIR  # .opencode/skills/chrome-devtools/scripts
-
-# Option A: Inject cookies
-node inject-auth.js --url https://example.com --cookies '[{"name":"session","value":"abc123","domain":".example.com"}]'
-
-# Option B: Inject Bearer token
-node inject-auth.js --url https://example.com --token "Bearer eyJhbGciOi..." --header Authorization --token-key access_token
-
-# Option C: Inject localStorage
-node inject-auth.js --url https://example.com --local-storage '{"auth_token":"xyz","user_id":"123"}'
-```
-
-### Step 4: Run Tests
-After auth injection, run tests normally:
-```bash
-node navigate.js --url https://example.com/dashboard
-node screenshot.js --url https://example.com/profile --output profile.png
-```
-
-## Workflow
-- Use `ck:plan` skill to organize the test plan & report
-- All screenshots saved in the same report directory
-- Browse URL, discover all pages, components, endpoints
-- Create test plan based on discovered structure
-- Use multiple `tester` subagents in parallel for: pages, forms, navigation, user flows, accessibility, responsive layouts, performance, security, seo
-- Use `ck:ai-multimodal` to analyze all screenshots
-- Generate comprehensive Markdown report
-- Ask user if they want to preview with `/ck:preview`
-
-## Output Requirements
-- Clear, structured Markdown with headers, lists, code blocks
-- Include test results summary, key findings, screenshot references
-- Ensure token efficiency while maintaining high quality
-- Sacrifice grammar for concision
-
-**Do not** start implementing fixes.

package/.opencode/skills/test/references/ui.md

@@ -1,87 +0,0 @@
-Activate the chrome-devtools skill.
-
-## Purpose
-Run comprehensive UI tests on a website and generate a detailed report.
-
-## Arguments
-- $1: URL - The URL of the website to test
-- $2: OPTIONS - Optional test configuration (e.g., --headless, --mobile, --auth)
-
-## Testing Protected Routes (Authentication)
-
-For testing protected routes that require authentication, follow this workflow:
-
-### Step 1: User Manual Login
-Instruct the user to:
-1. Open the target site in their browser
-2. Log in manually with their credentials
-3. Open browser DevTools (F12) → Application tab → Cookies/Storage
-
-### Step 2: Extract Auth Credentials
-Ask the user to provide one of:
-- **Cookies**: Copy cookie values (name, value, domain)
-- **Access Token**: Copy JWT/Bearer token from localStorage or cookies
-- **Session Storage**: Copy relevant session keys
-
-### Step 3: Inject Authentication
-Use the `inject-auth.js` script to inject credentials before testing:
-
-```bash
-cd $SKILL_DIR  # .opencode/skills/chrome-devtools/scripts
-
-# Option A: Inject cookies
-node inject-auth.js --url https://example.com --cookies '[{"name":"session","value":"abc123","domain":".example.com"}]'
-
-# Option B: Inject Bearer token
-node inject-auth.js --url https://example.com --token "Bearer eyJhbGciOi..." --header Authorization --token-key access_token
-
-# Option C: Inject localStorage
-node inject-auth.js --url https://example.com --local-storage '{"auth_token":"xyz","user_id":"123"}'
-
-# Combined (cookies + localStorage)
-node inject-auth.js --url https://example.com --cookies '[{"name":"session","value":"abc"}]' --local-storage '{"user":"data"}'
-```
-
-### Step 4: Run Tests
-After auth injection, the browser session persists. Run tests normally:
-
-```bash
-# Navigate and screenshot protected pages
-node navigate.js --url https://example.com/dashboard
-node screenshot.js --url https://example.com/profile --output profile.png
-
-# The auth session persists until --close true is used
-node screenshot.js --url https://example.com/settings --output settings.png --close true
-```
-
-### Auth Script Options
-- `--cookies '<json>'` - Inject cookies (JSON array)
-- `--token '<token>'` - Inject Bearer token
-- `--token-key '<key>'` - localStorage key for token (default: access_token)
-- `--header '<name>'` - Set HTTP header with token (e.g., Authorization)
-- `--local-storage '<json>'` - Inject localStorage items
-- `--session-storage '<json>'` - Inject sessionStorage items
-- `--reload true` - Reload page after injection
-- `--clear true` - Clear saved auth session
-
-## Workflow
-- Use `planning` skill to organize the test plan & report in the current project directory.
-- All the screenshots should be saved in the same report directory.
-- Browse $URL with the specified $OPTIONS, discover all pages, components, and endpoints.
-- Create a test plan based on the discovered structure
-- Use multiple `tester` subagents or tool calls in parallel to test all pages, forms, navigation, user flows, accessibility, functionalities, usability, responsive layouts, cross-browser compatibility, performance, security, seo, etc.
-- Use `ai-multimodal` to analyze all screenshots and visual elements.
-- Generate a comprehensive report in Markdown format, embedding all screenshots directly in the report.
-- Finally respond to the user with a concise summary of findings and recommendations.
-- Use `AskUserQuestion` tool to ask if user wants to preview the report with `/preview` slash command.
-
-## Output Requirements
-How to write reports:
-- Format: Use clear, structured Markdown with headers, lists, and code blocks where appropriate
-- Include the test results summary, key findings, and screenshot references
-- **IMPORTANT:** Ensure token efficiency while maintaining high quality.
-- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
-- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
-
-**IMPORTANT**: **Do not** start implementing the fixes.
-**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.

package/.opencode/skills/test/references/workflow.md

@@ -1,102 +0,0 @@
-# Workflow Test Runner
-
-Execute ClaudeKit workflow tests with manual verification at each step.
-
-## Workflow Options
-
-| Workflow | Steps | Description |
-|----------|-------|-------------|
-| `youtube` | 5 | YouTube → social, blog, infographic |
-| `content` | 3 | Topic → blog → CRO → social |
-| `email` | 2 | Flow type → sequence → copywriting |
-| `brand` | 3 | Brand context → update → verify |
-| `all` | 13 | Run all workflows |
-
-## Execution Protocol
-
-### Step 1: Scan Components
-
-```bash
-python3 .opencode/skills/test/scripts/scan-components.py --json --scenarios
-```
-
-### Step 2: Load Workflow
-
-Based on `$ARGUMENTS`, load the appropriate workflow from test skill.
-
-### Step 3: For Each Step
-
-1. **Display:**
-   ```
-   [STEP {n}/{total}] {step_name}
-   ─────────────────────────────────────────
-   Action: {action}
-   Input: {input}
-   Verify: {checklist}
-   ```
-
-2. **Execute actual command/skill/agent**
-   - Use happy case prompts
-   - Capture output
-
-3. **Show output and ask:**
-   - Use AskUserQuestion: Pass / Fail / Skip
-   - Log result
-
-4. **Continue or stop**
-
-### Step 4: Report
-
-```
-═══════════════════════════════════════════
-WORKFLOW TEST: {workflow}
-═══════════════════════════════════════════
-Pass: {n} | Fail: {n} | Skip: {n}
-
-{details}
-```
-
-## Happy Case Prompts
-
-| Key | Value |
-|-----|-------|
-| `youtube_url` | `https://www.youtube.com/watch?v=dQw4w9WgXcQ` |
-| `blog_topic` | `10 productivity tips for remote workers` |
-| `email_flow` | `welcome` |
-| `brand_preset` | `ocean-professional` |
-
-## Workflow Definitions
-
-### youtube
-| Step | Action | Input | Verify |
-|------|--------|-------|--------|
-| 1 | VidCap info | youtube_url | Returns title, duration |
-| 2 | VidCap summary | youtube_url | Returns structured content |
-| 3 | /youtube:social | youtube_url | Multi-platform posts |
-| 4 | /youtube:blog | youtube_url | SEO article |
-| 5 | /youtube:infographic | youtube_url | Visual layout |
-
-### content
-| Step | Action | Input | Verify |
-|------|--------|-------|--------|
-| 1 | /content:blog | blog_topic | Article with frontmatter |
-| 2 | /content:cro | article | CRO optimization |
-| 3 | /social | summary | Platform posts |
-
-### email
-| Step | Action | Input | Verify |
-|------|--------|-------|--------|
-| 1 | /email:flow | email_flow | 5-email sequence |
-| 2 | copywriting skill | sequence | PAS/AIDA applied |
-
-### brand
-| Step | Action | Input | Verify |
-|------|--------|-------|--------|
-| 1 | inject-brand-context.cjs | - | Returns JSON |
-| 2 | /brand:update | brand_preset | Tokens synced |
-| 3 | Content generation | any | Brand voice applied |
-
-## Skills Required
-
-- `test`
-- `debugging` (failure analysis)

package/.opencode/skills/test/scripts/scan-components.py

@@ -1,281 +0,0 @@
-#!/usr/bin/env python3
-"""
-Scan ClaudeKit components and generate test scenarios.
-Outputs JSON with all testable commands, agents, skills, and workflows.
-"""
-
-import os
-import json
-import re
-from pathlib import Path
-from typing import Dict, List, Any
-
-# Base path - adjust if running from different location
-BASE_PATH = Path(__file__).parent.parent.parent.parent.parent
-
-def extract_frontmatter(content: str) -> Dict[str, str]:
-    """Extract YAML frontmatter from markdown file."""
-    if not content.startswith('---'):
-        return {}
-
-    parts = content.split('---', 2)
-    if len(parts) < 3:
-        return {}
-
-    frontmatter = {}
-    for line in parts[1].strip().split('\n'):
-        if ':' in line:
-            key, value = line.split(':', 1)
-            frontmatter[key.strip()] = value.strip().strip('"\'')
-
-    return frontmatter
-
-def scan_commands() -> List[Dict[str, Any]]:
-    """Scan all commands in .opencode/commands/"""
-    commands = []
-    cmd_path = BASE_PATH / '.claude' / 'commands'
-
-    if not cmd_path.exists():
-        return commands
-
-    for md_file in cmd_path.rglob('*.md'):
-        try:
-            content = md_file.read_text()
-            fm = extract_frontmatter(content)
-
-            # Build command path (e.g., /youtube:social)
-            rel_path = md_file.relative_to(cmd_path)
-            parts = list(rel_path.parts)
-
-            if len(parts) == 1:
-                # Root command like social.md -> /social
-                cmd_name = f"/{parts[0].replace('.md', '')}"
-            else:
-                # Nested like youtube/social.md -> /youtube:social
-                folder = parts[0]
-                name = parts[-1].replace('.md', '')
-                cmd_name = f"/{folder}:{name}"
-
-            commands.append({
-                'name': cmd_name,
-                'path': str(md_file.relative_to(BASE_PATH)),
-                'description': fm.get('description', ''),
-                'argument_hint': fm.get('argument-hint', ''),
-                'testable': True
-            })
-        except Exception as e:
-            print(f"Error scanning {md_file}: {e}")
-
-    return sorted(commands, key=lambda x: x['name'])
-
-def scan_agents() -> List[Dict[str, Any]]:
-    """Scan all agents in .opencode/agents/"""
-    agents = []
-    agent_path = BASE_PATH / '.claude' / 'agents'
-
-    if not agent_path.exists():
-        return agents
-
-    for md_file in agent_path.glob('*.md'):
-        try:
-            content = md_file.read_text()
-            fm = extract_frontmatter(content)
-
-            agents.append({
-                'name': md_file.stem,
-                'path': str(md_file.relative_to(BASE_PATH)),
-                'description': fm.get('description', ''),
-                'model': fm.get('model', 'sonnet'),
-                'testable': True
-            })
-        except Exception as e:
-            print(f"Error scanning {md_file}: {e}")
-
-    return sorted(agents, key=lambda x: x['name'])
-
-def scan_skills() -> List[Dict[str, Any]]:
-    """Scan all skills in .opencode/skills/"""
-    skills = []
-    skill_path = BASE_PATH / '.claude' / 'skills'
-
-    if not skill_path.exists():
-        return skills
-
-    for skill_dir in skill_path.iterdir():
-        if not skill_dir.is_dir():
-            continue
-
-        skill_file = skill_dir / 'SKILL.md'
-        if not skill_file.exists():
-            continue
-
-        try:
-            content = skill_file.read_text()
-            fm = extract_frontmatter(content)
-
-            # Check for scripts
-            scripts_dir = skill_dir / 'scripts'
-            has_scripts = scripts_dir.exists() and any(scripts_dir.iterdir())
-
-            # Check for references
-            refs_dir = skill_dir / 'references'
-            has_refs = refs_dir.exists() and any(refs_dir.iterdir())
-
-            skills.append({
-                'name': fm.get('name', skill_dir.name),
-                'path': str(skill_dir.relative_to(BASE_PATH)),
-                'description': fm.get('description', ''),
-                'has_scripts': has_scripts,
-                'has_references': has_refs,
-                'testable': has_scripts  # Only testable if has executable scripts
-            })
-        except Exception as e:
-            print(f"Error scanning {skill_dir}: {e}")
-
-    return sorted(skills, key=lambda x: x['name'])
-
-def scan_workflows() -> List[Dict[str, Any]]:
-    """Scan all workflows in .opencode/workflows/"""
-    workflows = []
-    wf_path = BASE_PATH / '.claude' / 'workflows'
-
-    if not wf_path.exists():
-        return workflows
-
-    for md_file in wf_path.glob('*.md'):
-        try:
-            content = md_file.read_text()
-            fm = extract_frontmatter(content)
-
-            workflows.append({
-                'name': md_file.stem,
-                'path': str(md_file.relative_to(BASE_PATH)),
-                'description': fm.get('description', ''),
-                'testable': False  # Workflows are documentation, not directly testable
-            })
-        except Exception as e:
-            print(f"Error scanning {md_file}: {e}")
-
-    return sorted(workflows, key=lambda x: x['name'])
-
-def generate_test_scenarios(commands: List, skills: List) -> List[Dict[str, Any]]:
-    """Generate test scenarios based on scanned components."""
-    scenarios = []
-
-    # Happy case prompts
-    happy_cases = {
-        'youtube_url': 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
-        'blog_topic': '10 productivity tips for remote workers',
-        'email_flow': 'welcome',
-        'brand_preset': 'ocean-professional',
-        'social_platform': 'twitter',
-        'writing_style': 'casual'
-    }
-
-    # Generate scenarios for key commands
-    for cmd in commands:
-        name = cmd['name']
-
-        if 'youtube' in name:
-            scenarios.append({
-                'name': f"Test {name}",
-                'type': 'command',
-                'steps': [
-                    {
-                        'action': name,
-                        'input': happy_cases['youtube_url'],
-                        'verify': ['Output generated', 'No errors', 'Format correct']
-                    }
-                ]
-            })
-        elif 'content' in name or 'blog' in name:
-            scenarios.append({
-                'name': f"Test {name}",
-                'type': 'command',
-                'steps': [
-                    {
-                        'action': name,
-                        'input': happy_cases['blog_topic'],
-                        'verify': ['Content generated', 'SEO metadata present']
-                    }
-                ]
-            })
-        elif 'email' in name:
-            scenarios.append({
-                'name': f"Test {name}",
-                'type': 'command',
-                'steps': [
-                    {
-                        'action': name,
-                        'input': happy_cases['email_flow'],
-                        'verify': ['Sequence generated', 'Timing defined']
-                    }
-                ]
-            })
-        elif 'social' in name:
-            scenarios.append({
-                'name': f"Test {name}",
-                'type': 'command',
-                'steps': [
-                    {
-                        'action': name,
-                        'input': happy_cases['social_platform'],
-                        'verify': ['Posts generated', 'Platform format correct']
-                    }
-                ]
-            })
-
-    return scenarios
-
-def main():
-    """Main entry point."""
-    import argparse
-
-    parser = argparse.ArgumentParser(description='Scan ClaudeKit components')
-    parser.add_argument('--json', action='store_true', help='Output as JSON')
-    parser.add_argument('--scenarios', action='store_true', help='Generate test scenarios')
-    parser.add_argument('--type', choices=['commands', 'agents', 'skills', 'workflows', 'all'],
-                       default='all', help='Component type to scan')
-    args = parser.parse_args()
-
-    result = {}
-
-    if args.type in ['commands', 'all']:
-        result['commands'] = scan_commands()
-    if args.type in ['agents', 'all']:
-        result['agents'] = scan_agents()
-    if args.type in ['skills', 'all']:
-        result['skills'] = scan_skills()
-    if args.type in ['workflows', 'all']:
-        result['workflows'] = scan_workflows()
-
-    if args.scenarios:
-        result['scenarios'] = generate_test_scenarios(
-            result.get('commands', []),
-            result.get('skills', [])
-        )
-
-    if args.json:
-        print(json.dumps(result, indent=2))
-    else:
-        # Summary output
-        print("=" * 60)
-        print("ClaudeKit Component Scan")
-        print("=" * 60)
-
-        for comp_type, items in result.items():
-            if comp_type == 'scenarios':
-                continue
-            testable = sum(1 for i in items if i.get('testable', False))
-            print(f"\n{comp_type.upper()}: {len(items)} total, {testable} testable")
-            for item in items[:10]:  # Show first 10
-                status = "✓" if item.get('testable') else "○"
-                print(f"  {status} {item['name']}")
-            if len(items) > 10:
-                print(f"  ... and {len(items) - 10} more")
-
-        if args.scenarios and 'scenarios' in result:
-            print(f"\nTEST SCENARIOS: {len(result['scenarios'])} generated")
-
-if __name__ == '__main__':
-    main()