@manhnv319/codexkit 0.1.0

package/.agents/skills/team/references/agent-teams-official-docs.md

@@ -0,0 +1,175 @@
+# Agent Teams — Overview & Architecture
+
+> **Canonical source:** https://code.claude.com/docs/en/agent-teams
+> **Version captured:** Claude Code (Feb 2026)
+> **Update policy:** Re-fetch canonical URL when Claude Code releases new Agent Teams features.
+
+This is a **self-contained knowledge base** — AI agents should NOT need to re-fetch the URL.
+
+## Overview
+
+Agent Teams coordinate multiple Claude Code instances working together. One session acts as the team lead, coordinating work, assigning tasks, and synthesizing results. Teammates work independently, each in its own context window, and communicate directly with each other.
+
+Unlike subagents (run within a single session, report back only), teammates are full independent sessions you can interact with directly.
+
+## When to Use
+
+Best for tasks where parallel exploration adds real value:
+
+- **Research and review**: multiple teammates investigate different aspects, share and challenge findings
+- **New modules or features**: teammates each own a separate piece without conflicts
+- **Debugging with competing hypotheses**: test different theories in parallel
+- **Cross-layer coordination**: changes spanning frontend, backend, tests — each owned by different teammate
+
+**Not suitable for:** sequential tasks, same-file edits, work with many dependencies.
+
+### Subagents vs Agent Teams
+
+| | Subagents | Agent Teams |
+|---|---|---|
+| **Context** | Own window; results return to caller | Own window; fully independent |
+| **Communication** | Report back to main agent only | Message each other directly |
+| **Coordination** | Main agent manages all work | Shared task list, self-coordination |
+| **Best for** | Focused tasks, result-only | Complex work requiring discussion |
+| **Token cost** | Lower | Higher (each teammate = separate instance) |
+
+## Enable
+
+Still experimental — requires opt-in:
+
+```json
+{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
+```
+
+Set in shell environment or settings.json.
+
+## How Teams Start
+
+Two paths:
+1. **You request**: describe task + ask for agent team. Claude creates based on instructions.
+2. **Claude proposes**: suggests team if task benefits from parallel work.
+
+Both require your confirmation. Claude won't create a team without approval.
+
+## Architecture
+
+| Component | Role |
+|-----------|------|
+| **Team lead** | Main session — creates team, spawns teammates, coordinates |
+| **Teammates** | Separate Claude Code instances with own context windows |
+| **Task list** | Shared work items at `~/.codex/tasks/{team-name}/` |
+| **Mailbox** | Messaging system for inter-agent communication |
+
+Storage:
+- **Team config**: `~/.codex/teams/{team-name}/config.json` (members array with name, agent ID, type)
+- **Task list**: `~/.codex/tasks/{team-name}/`
+
+Task dependencies managed automatically — completing a blocking task unblocks dependents without manual intervention.
+
+## Tools API Surface
+
+### TeamCreate
+
+Create team + task list. Params: `team_name`, `description`.
+
+### TeamDelete
+
+Remove team/task dirs. **Takes NO parameters** — just call `TeamDelete` with empty params. Fails if active teammates still exist.
+
+### SendMessage Types
+
+| Type | Purpose |
+|------|---------|
+| `message` | DM to one teammate (requires `recipient`) |
+| `broadcast` | Send to ALL teammates (use sparingly — costs scale with N) |
+| `shutdown_request` | Ask teammate to gracefully exit |
+| `shutdown_response` | Teammate approves/rejects shutdown (requires `request_id`) |
+| `plan_approval_response` | Lead approves/rejects teammate plan (requires `request_id`) |
+
+### Task System Fields
+
+| Field | Values/Purpose |
+|-------|---------------|
+| `status` | `pending` → `in_progress` → `completed` (or `deleted`) |
+| `owner` | Agent name assigned to task |
+| `blocks` | Task IDs this task blocks (read via TaskGet) |
+| `blockedBy` | Task IDs that must complete first (read via TaskGet) |
+| `addBlocks` | Set blocking relations (write via TaskUpdate) |
+| `addBlockedBy` | Set dependency relations (write via TaskUpdate) |
+| `metadata` | Arbitrary key-value pairs |
+| `subject` | Brief imperative title |
+| `description` | Full requirements and context |
+
+Task claiming uses file locking to prevent race conditions.
+
+## Hook Events (2.1.33+)
+
+### TaskCompleted
+
+Fires when teammate calls `TaskUpdate` with `status: "completed"`.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `task_id` | string | Completed task ID |
+| `task_subject` | string | Task title |
+| `task_description` | string | Full task description |
+| `teammate_name` | string | Who completed it |
+| `team_name` | string | Team name |
+
+Note: Does NOT include `permission_mode`.
+
+### TeammateIdle
+
+Fires after `SubagentStop` for team members.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `teammate_name` | string | Idle teammate name |
+| `team_name` | string | Team name |
+
+Note: Includes `permission_mode`. Always pairs with SubagentStop.
+
+### Event Lifecycle
+
+```
+SubagentStart(worker) → TaskCompleted(task) → SubagentStop(worker) → TeammateIdle(worker)
+```
+
+TaskCompleted fires BEFORE SubagentStop/TeammateIdle.
+
+## Agent Memory
+
+Agents can declare `memory` in frontmatter for persistent cross-session learning.
+
+| Scope | Location | Persists across |
+|-------|----------|-----------------|
+| `user` | `~/.codex/agent-memory/<name>/` | All projects |
+| `project` | `.codex/agent-memory/<name>/` | Sessions in same project |
+
+First 200 lines of `MEMORY.md` auto-injected into system prompt.
+
+## Task(agent_type) Restrictions
+
+Limit which sub-agents an agent can spawn:
+
+```yaml
+tools: Read, Grep, Bash, Task(Explore)
+```
+
+This agent can only spawn `Explore` sub-agents. Restricts recursive spawning and cost escalation.
+
+## Context & Communication
+
+Each teammate loads: CLAUDE.md, MCP servers, skills, agents. Receives spawn prompt from lead. Lead's conversation history does NOT carry over.
+
+- **Automatic message delivery** — no polling needed
+- **Idle notifications** — teammates notify lead when turn ends
+- **Shared task list** — all agents see status and claim work
+
+## Permissions
+
+Teammates inherit lead's permission settings at spawn. If lead uses `--dangerously-skip-permissions`, all teammates do too. Can change individually after spawning but not at spawn time.
+
+## Token Usage
+
+Scales with active teammates. Worth it for research/review/features. Single session more cost-effective for routine tasks.

package/.agents/skills/template-skill/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: ck:template-skill
+description: Replace with description of the skill and when Claude should use it.
+---
+
+# Insert instructions below

package/.agents/skills/test/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: ck:test
+description: "Run unit, integration, e2e, and UI tests. Use for test execution, coverage analysis, build verification, visual regression, and QA reports."
+argument-hint: "[context] OR ui [url]"
+version: 1.0.0
+---
+
+# Testing & Quality Assurance
+
+Comprehensive testing framework covering code-level testing (unit, integration, e2e), UI/visual testing via browser automation, coverage analysis, and structured QA reporting.
+
+## Default (No Arguments)
+
+If invoked with context (test scope), proceed with testing. If invoked WITHOUT arguments, use `AskUserQuestion` to present available test operations:
+
+| Operation | Description |
+|-----------|-------------|
+| `(default)` | Run unit/integration/e2e tests |
+| `ui` | Run UI tests on a website |
+
+Present as options via `AskUserQuestion` with header "Test Operation", question "What would you like to do?".
+
+## Core Principle
+
+**NEVER IGNORE FAILING TESTS.** Fix root causes, not symptoms. No mocks/cheats/tricks to pass builds.
+
+## When to Use
+
+- **After implementation**: Validate new features or bug fixes
+- **Coverage checks**: Ensure coverage meets project thresholds (80%+)
+- **UI verification**: Visual regression, responsive layout, accessibility
+- **Build validation**: Verify build process, dependencies, CI/CD compatibility
+- **Pre-commit/push**: Final quality gate
+
+## Workflows
+
+### 1. Code Testing (`references/test-execution-workflow.md`)
+
+Execute test suites, analyze results, generate coverage. Supports JS/TS (Jest/Vitest/Mocha), Python (pytest), Go, Rust, Flutter. Includes working process, quality standards, and tool commands.
+
+**Load when:** Running unit/integration/e2e tests, checking coverage, validating builds
+
+### 2. UI Testing (`references/ui-testing-workflow.md`)
+
+Browser-based visual testing via `ck:chrome-devtools` skill. Screenshots, responsive checks, accessibility audits, form automation, console error collection. Includes auth injection for protected routes.
+
+**Load when:** Visual regression testing, UI bugs, responsive layout checks, accessibility audits
+
+### 3. Report Format (`references/report-format.md`)
+
+Structured QA report template: test results overview, coverage metrics, failed tests, performance, build status, recommendations.
+
+**Load when:** Generating test summary reports
+
+## Quick Reference
+
+```
+Code tests     → test-execution-workflow.md
+  npm test / pytest / go test / cargo test / flutter test
+  Coverage: npm run test:coverage / pytest --cov
+
+UI tests       → ui-testing-workflow.md
+  Screenshots, responsive, a11y, forms, console errors
+  Auth: inject-auth.js for protected routes
+
+Reports        → report-format.md
+  Structured QA summary with metrics & recommendations
+```
+
+## Working Process
+
+1. Identify testing scope from recent changes or requirements
+2. Run typecheck/analyze commands to catch syntax errors first
+3. Execute appropriate test suites
+4. Analyze results — focus on failures
+5. Generate coverage reports if applicable
+6. For frontend: run UI tests via `ck:chrome-devtools` skill
+7. Produce structured summary report
+
+## Tools Integration
+
+- **Test runners**: Jest, Vitest, Mocha, pytest, go test, cargo test, flutter test
+- **Coverage**: Istanbul/c8/nyc, pytest-cov, go cover
+- **Browser**: `ck:chrome-devtools` skill for UI testing (screenshots, ARIA, console, network)
+- **Analysis**: `ck:ai-multimodal` skill for screenshot analysis
+- **Debugging**: `ck:debug` skill when tests reveal bugs requiring investigation
+- **Thinking**: `ck:sequential-thinking` skill for complex test failure analysis
+
+## Quality Standards
+
+- All critical paths must have test coverage
+- Validate happy path AND error scenarios
+- Ensure test isolation — no interdependencies
+- Tests must be deterministic and reproducible
+- Clean up test data after execution
+- Never ignore failing tests to pass the build
+
+## Report Output
+
+Use naming pattern from `## Naming` section injected by hooks.
+
+## Team Mode
+
+When operating as teammate:
+1. On start: check `TaskList`, claim assigned/next unblocked task via `TaskUpdate`
+2. Read full task description via `TaskGet` before starting
+3. Wait for blocked tasks (implementation) to complete before testing
+4. Respect file ownership — only create/edit test files assigned
+5. When done: `TaskUpdate(status: "completed")` then `SendMessage` results to lead

package/.agents/skills/test/references/report-format.md

@@ -0,0 +1,58 @@
+# Test Report Format
+
+Structured QA report template. Sacrifice grammar for concision.
+
+## Template
+
+```markdown
+# Test Report — {date} — {scope}
+
+## Test Results Overview
+- **Total**: X tests
+- **Passed**: X | **Failed**: X | **Skipped**: X
+- **Duration**: Xs
+
+## Coverage Metrics
+| Metric   | Value | Threshold | Status |
+|----------|-------|-----------|--------|
+| Lines    | X%    | 80%       | PASS/FAIL |
+| Branches | X%    | 70%       | PASS/FAIL |
+| Functions| X%    | 80%       | PASS/FAIL |
+
+## Failed Tests
+### `test/path/file.test.ts` — TestName
+- **Error**: Error message
+- **Stack**: Relevant stack trace (truncated)
+- **Cause**: Brief root cause analysis
+- **Fix**: Suggested resolution
+
+## UI Test Results (if applicable)
+- **Pages tested**: X
+- **Screenshots**: ./screenshots/
+- **Console errors**: none | [list]
+- **Responsive**: checked at [viewports] | skipped
+- **Performance**: LCP Xs, FID Xms, CLS X
+
+## Build Status
+- **Build**: PASS/FAIL
+- **Warnings**: none | [list]
+- **Dependencies**: all resolved | [issues]
+
+## Critical Issues
+1. [Blocking issue description + impact]
+
+## Recommendations
+1. [Actionable improvement with priority]
+
+## Unresolved Questions
+- [Any open questions, if any]
+```
+
+## Guidelines
+
+- Include ALL failed tests with error messages — don't summarize away details
+- Coverage: highlight specific uncovered files/functions, not just percentages
+- Screenshots: embed paths directly in report for easy access
+- Recommendations: prioritize by impact (critical > high > medium > low)
+- Keep report under 200 lines — split into sections if larger scope needed
+- Save report using naming pattern from `## Naming` section injected by hooks

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

@@ -0,0 +1,103 @@
+# 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/.agents/skills/test/references/ui-testing-workflow.md

@@ -0,0 +1,65 @@
+# 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  # .agents/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/.agents/skills/threejs/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: ck:threejs
+description: "Build 3D web apps with Three.js (WebGL/WebGPU). 556 searchable examples, 60 API classes, 20 use cases. Actions: create 3D scene, load model, add animation, implement physics, build VR/XR. Topics: GLTF loader, PBR materials, particle effects, shadows, post-processing, compute shaders, TSL. Integrations: WebGPU, physics engines, spatial audio."
+license: MIT
+version: 3.0.0
+argument-hint: "[3D scene or feature]"
+---
+
+# Three.js Development
+
+Build high-performance 3D web applications using Three.js. Contains 556 searchable examples across 13 categories, 60 API classes, and 20 use-case templates.
+
+## When to Use
+
+- Building 3D scenes, games, or visualizations
+- Loading 3D models (GLTF, FBX, OBJ)
+- Implementing animations, physics, or VR/XR
+- Creating particle effects or custom shaders
+- Optimizing rendering performance
+
+## Search Examples & API
+
+Use the search CLI to find relevant examples and API references:
+
+```bash
+python3 .agents/skills/threejs/scripts/search.py "<query>" [--domain <domain>] [-n <max_results>]
+```
+
+### Search Domains
+
+| Domain | Use For | Example Query |
+|--------|---------|---------------|
+| `examples` | Find code examples | `"particle effects gpu"` |
+| `api` | Class/method reference | `"PerspectiveCamera"` |
+| `use-cases` | Project recommendations | `"product configurator"` |
+| `categories` | Browse categories | `"webgpu"` |
+
+### Quick Examples
+
+```bash
+# Find particle/compute examples
+python3 .agents/skills/threejs/scripts/search.py "particle compute webgpu"
+
+# Search API for camera classes
+python3 .agents/skills/threejs/scripts/search.py "camera" --domain api
+
+# Get examples for a use case
+python3 .agents/skills/threejs/scripts/search.py "product configurator" --use-case
+
+# Filter by category
+python3 .agents/skills/threejs/scripts/search.py --category webgpu -n 10
+
+# Filter by complexity
+python3 .agents/skills/threejs/scripts/search.py --complexity high -n 5
+```
+
+## Example Categories
+
+| Category | Count | Description |
+|----------|-------|-------------|
+| `webgl` | 216 | Standard WebGL rendering |
+| `webgpu (wip)` | 190 | Modern WebGPU + compute shaders |
+| `webgl / advanced` | 48 | Low-level GPU, custom shaders |
+| `webgl / postprocessing` | 27 | Bloom, SSAO, SSR, DOF |
+| `webxr` | 26 | VR/AR experiences |
+| `physics` | 13 | Physics simulation |
+
+## Common Use Cases
+
+| Use Case | Recommended | Complexity |
+|----------|-------------|------------|
+| Product Configurator | GLTF, PBR, EnvMaps | Medium |
+| Game Development | Animation, Physics, Controls | High |
+| Data Visualization | BufferGeometry, Points | Medium |
+| 360 Panorama | Equirectangular, WebXR | Low |
+| Architectural Viz | GLTF, HDR, CSM Shadows | High |
+
+## Quick Start
+
+```javascript
+// 1. Scene, Camera, Renderer
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
+const renderer = new THREE.WebGLRenderer({ antialias: true });
+renderer.setSize(window.innerWidth, window.innerHeight);
+renderer.setPixelRatio(window.devicePixelRatio);
+document.body.appendChild(renderer.domElement);
+
+// 2. Lighting
+scene.add(new THREE.AmbientLight(0x404040));
+const dirLight = new THREE.DirectionalLight(0xffffff, 1);
+dirLight.position.set(5, 5, 5);
+scene.add(dirLight);
+
+// 3. Load GLTF Model
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+const loader = new GLTFLoader();
+loader.load('model.glb', (gltf) => scene.add(gltf.scene));
+
+// 4. Animation Loop
+function animate() {
+  requestAnimationFrame(animate);
+  renderer.render(scene, camera);
+}
+animate();
+```
+
+## Progressive Reference Files
+
+### Level 1: Fundamentals
+- `references/00-fundamentals.md` - Core concepts, scene graph
+- `references/01-getting-started.md` - Setup, basic rendering
+
+### Level 2: Common Tasks
+- `references/02-loaders.md` - GLTF, FBX, OBJ loaders
+- `references/03-textures.md` - Texture types, mapping
+- `references/04-cameras.md` - Camera types, controls
+- `references/05-lights.md` - Light types, shadows
+- `references/06-animations.md` - AnimationMixer, clips
+- `references/11-materials.md` - PBR, standard materials
+- `references/18-geometry.md` - BufferGeometry, primitives
+
+### Level 3: Interactive
+- `references/08-interaction.md` - Raycasting, picking
+- `references/09-postprocessing.md` - Bloom, SSAO, SSR
+- `references/10-controls.md` - OrbitControls, etc.
+
+### Level 4: Advanced
+- `references/12-performance.md` - Instancing, LOD, batching
+- `references/13-node-materials.md` - TSL shader graphs
+- `references/17-shader.md` - Custom GLSL shaders
+
+### Level 5: Specialized
+- `references/14-physics-vr.md` - Physics, WebXR
+- `references/16-webgpu.md` - WebGPU, compute shaders
+
+## External Resources
+
+- Docs: https://threejs.org/docs/
+- Examples: https://threejs.org/examples/
+- Editor: https://threejs.org/editor/
+- Discord: https://discord.gg/56GBJwAnUS