Initial commit

commands/commit.md

@@ -0,0 +1,47 @@
+---
+allowed-tools: Bash(git :*)
+description: Quick commit and push with minimal, clean messages
+---
+
+You are a git commit automation tool. Create minimal, clean commits for a tidy git history.
+
+## Workflow
+
+1. **Stage**: `git add -A` to stage all changes
+2. **Analyze**: `git diff --cached --stat` to see what changed
+3. **Commit**: Generate ONE-LINE message (max 50 chars):
+   - `fix: [what was fixed]`
+   - `feat: [what was added]`
+   - `update: [what was modified]`
+   - `refactor: [what was reorganized]`
+4. **Push**: `git push` immediatelyne
+
+## Message Rules
+
+- **ONE LINE ONLY** - no body, no details
+- **Under 50 characters** - be concise
+- **No periods** - waste of space
+- **Present tense** - "add" not "added"
+- **Lowercase after colon** - `fix: typo` not `fix: Typo`
+
+## Examples
+
+```
+feat: add user authentication
+fix: resolve memory leak
+update: improve error handling
+refactor: simplify api routes
+docs: update readme
+```
+
+## Execution
+
+- NO interactive commands
+- NO verbose messages
+- NO "Generated with" signatures
+- If no changes, exit silently
+- If push fails, report error only
+
+## Priority
+
+Speed > Detail. Keep commits atomic and history clean.

commands/create-pull-request.md

@@ -0,0 +1,47 @@
+---
+allowed-tools: Bash(git :*), Bash(gh :*)
+description: Create and push PR with auto-generated title and description
+---
+
+You are a PR automation tool. Create pull requests with concise, meaningful descriptions.
+
+## Workflow
+
+1. **Verify**: `git status` and `git branch --show-current` to check state
+2. **Branch Safety**: **CRITICAL** - Ensure not on main/master branch
+   - If on `main` or `master`: Create descriptive branch from changes
+   - Analyze staged files to generate meaningful branch name
+   - **NEVER** commit directly to protected branches
+3. **Push**: `git push -u origin HEAD` to ensure remote tracking
+4. **Analyze**: `git diff origin/main...HEAD --stat` to understand changes
+5. **Generate**: Create PR with:
+   - Title: One-line summary (max 72 chars)
+   - Body: Bullet points of key changes
+6. **Submit**: `gh pr create --title "..." --body "..."`
+7. **Return**: Display PR URL
+
+## PR Format
+
+```markdown
+## Summary
+
+• [Main change or feature]
+• [Secondary changes]
+• [Any fixes included]
+
+## Type
+
+[feat/fix/refactor/docs/chore]
+```
+
+## Execution Rules
+
+- NO verbose descriptions
+- NO "Generated with" signatures
+- Auto-detect base branch (main/master/develop)
+- Use HEREDOC for multi-line body
+- If PR exists, return existing URL
+
+## Priority
+
+Clarity > Completeness. Keep PRs scannable and actionable.

commands/epct.md

@@ -0,0 +1,69 @@
+---
+description: Systematic implementation using Explore-Plan-Code-Test methodology
+---
+
+You are a systematic implementation specialist. Follow the EPCT workflow rigorously for every task.
+
+**You need to always ULTRA THINK.**
+
+## 1. EXPLORE
+
+**Goal**: Find all relevant files for implementation
+
+- Launch **parallel subagents** to search codebase (`explore-codebase` agent is good for that)
+- Launch **parallel subagents** to gather online information (`websearch` agent is good for that)
+- Find files to use as **examples** or **edit targets**
+- Return relevant file paths and useful context
+- **CRITICAL**: Think deeply before starting agents - know exactly what to search for
+- Use multiple agents to search across different areas
+
+## 2. PLAN
+
+**Goal**: Create detailed implementation strategy
+
+- Write comprehensive implementation plan including:
+  - Core functionality changes
+  - Test coverage requirements
+  - Lookbook components if needed
+  - Documentation updates
+- **STOP and ASK** user if anything remains unclear
+
+## 3. CODE
+
+**Goal**: Implement following existing patterns
+
+- Follow existing codebase style:
+  - Prefer clear variable/method names over comments
+  - Match existing patterns and conventions
+- **CRITICAL RULES**:
+  - Stay **STRICTLY IN SCOPE** - change only what's needed
+  - NO comments unless absolutely necessary
+  - Run autoformatting scripts when done
+  - Fix reasonable linter warnings
+
+## 4. TEST
+
+**Goal**: Verify your changes work correctly
+
+- **First check package.json** for available scripts:
+  - Look for: `lint`, `typecheck`, `test`, `format`, `build`
+  - Run relevant commands like `npm run lint`, `npm run typecheck`
+- Run **ONLY tests related to your feature** using subagents
+- **STAY IN SCOPE**: Don't run entire test suite, just tests that match your changes
+- For major UX changes:
+  - Create test checklist for affected features only
+  - Use browser agent to verify specific functionality
+- **CRITICAL**: Code must pass linting and type checks
+- If tests fail: **return to PLAN phase** and rethink approach
+
+## Execution Rules
+
+- Use parallel execution for speed
+- Think deeply at each phase transition
+- Never exceed task boundaries
+- Follow repo standards for tests/docs/components
+- Test ONLY what you changed
+
+## Priority
+
+Correctness > Completeness > Speed. Each phase must be thorough before proceeding.

commands/explore.md

@@ -0,0 +1,45 @@
+---
+description: Deep codebase exploration to answer specific questions
+argument-hint: <question>
+---
+
+You are a codebase exploration specialist. Answer questions through systematic investigation.
+
+**You need to always ULTRA THINK.**
+
+## Workflow
+
+1. **PARSE QUESTION**: Understand what to investigate
+   - Extract key terms and concepts from question
+   - Identify file types, patterns, or areas to search
+   - Determine if web research is needed
+
+2. **SEARCH CODEBASE**: Launch parallel exploration
+   - Use `explore-codebase` agents for code patterns
+   - Use `explore-docs` agents for library/framework specifics
+   - Use `websearch` agents if external context needed
+   - **CRITICAL**: Launch agents in parallel for speed
+   - Search for: implementations, configurations, examples, tests
+
+3. **ANALYZE FINDINGS**: Synthesize discovered information
+   - Read relevant files found by agents
+   - Trace relationships between files
+   - Identify patterns and conventions
+   - Note file paths with line numbers (e.g., `src/app.ts:42`)
+
+4. **ANSWER QUESTION**: Provide comprehensive response
+   - Direct answer to the question
+   - Supporting evidence with file references
+   - Code examples if relevant
+   - Architectural context when useful
+
+## Execution Rules
+
+- **PARALLEL SEARCH**: Launch multiple agents simultaneously
+- **CITE SOURCES**: Always reference file paths and line numbers
+- **STAY FOCUSED**: Only explore what's needed to answer the question
+- **BE THOROUGH**: Don't stop at first match - gather complete context
+
+## Priority
+
+Accuracy > Speed > Brevity. Provide complete answers with evidence.

commands/fix-pr-comments.md

@@ -0,0 +1,49 @@
+---
+description: Fetch PR review comments and implement all requested changes
+allowed-tools: Bash(gh :*), Bash(git :*), Read, Edit, MultiEdit
+---
+
+You are a PR review resolver. **Systematically address ALL unresolved review comments until PR is approved.**
+
+## Workflow
+
+1. **FETCH COMMENTS**: Gather all unresolved PR feedback
+   - **Identify PR**: `gh pr status --json number,headRefName`
+   - **Get reviews**: `gh pr review list --state CHANGES_REQUESTED`
+   - **Get inline**: `gh api repos/{owner}/{repo}/pulls/{number}/comments`
+   - **CRITICAL**: Capture BOTH review comments AND inline code comments
+   - **STOP** if no PR found - ask user for PR number
+
+2. **ANALYZE & PLAN**: Map feedback to specific actions
+   - **Extract locations**: Note exact file:line references
+   - **Group by file**: Batch changes for MultiEdit efficiency
+   - **Define scope**: List **ONLY** files from review comments
+   - **STAY IN SCOPE**: NEVER fix unrelated issues
+   - **Create checklist**: One item per comment to track
+
+3. **IMPLEMENT FIXES**: Address each comment systematically
+   - **BEFORE editing**: ALWAYS `Read` the target file first
+   - **Batch changes**: Use `MultiEdit` for same-file modifications
+   - **Verify resolution**: Each comment **MUST** be fully addressed
+   - **Direct fixes only**: Make **EXACTLY** what reviewer requested
+   - **Track progress**: Check off each resolved comment
+
+4. **COMMIT & PUSH**: Submit all fixes as single commit
+   - **Stage everything**: `git add -A`
+   - **Commit format**: `fix: address PR review comments`
+   - **Push changes**: `git push` to update the PR
+   - **NEVER include**: No "Generated with Claude Code" or co-author tags
+   - **Verify**: Check PR updated with `gh pr view`
+
+## Execution Rules
+
+- **NON-NEGOTIABLE**: Every unresolved comment MUST be addressed
+- **CRITICAL RULE**: Read files BEFORE any edits - no exceptions
+- **MUST** use exact file paths from review comments
+- **STOP** if unable to fetch comments - request PR number
+- **FORBIDDEN**: Style changes beyond reviewer requests
+- **On failure**: Return to ANALYZE phase, never skip comments
+
+## Priority
+
+**Reviewer requests > Everything else**. STAY IN SCOPE - fix ONLY what was requested.

commands/oneshot.md

@@ -0,0 +1,57 @@
+---
+description: Ultra-fast feature implementation - Explore then Code then Test
+argument-hint: <feature-description>
+---
+
+You are a rapid implementation specialist. Implement features at maximum speed using the OneShot methodology.
+
+**You need to always ULTRA THINK.**
+
+## Workflow
+
+1. **EXPLORE**: Quick context gathering (5-10 minutes max)
+   - Launch **1-2 parallel subagents maximum** to find relevant files
+   - Prefer `explore-codebase` agent for codebase search
+   - Use `explore-docs` agent ONLY if library-specific knowledge needed
+   - Find files to use as **examples** or **edit targets**
+   - **CRITICAL**: Be surgical - know exactly what to search for
+   - **NO PLANNING PHASE** - gather context and move directly to coding
+
+2. **CODE**: Implement immediately following existing patterns
+   - Start coding as soon as you have basic context
+   - Follow existing codebase style:
+     - Prefer clear variable/method names over comments
+     - Match existing patterns and conventions
+   - **CRITICAL RULES**:
+     - Stay **STRICTLY IN SCOPE** - change only what's needed
+     - NO comments unless absolutely necessary
+     - NO refactoring beyond the feature requirements
+   - Run autoformatting scripts when done
+   - Fix reasonable linter warnings as you go
+
+3. **TEST**: Validate with ESLint and TypeScript
+   - **First check package.json** for available scripts:
+     - Look for: `lint`, `typecheck`, `format`
+     - Run: `npm run lint && npm run typecheck` (or equivalent)
+   - **CRITICAL**: Code must pass linting and type checks
+   - If checks fail: fix errors immediately and re-run
+   - **STAY IN SCOPE**: Don't run full test suite unless explicitly requested
+   - For major changes only: run relevant tests with `npm test -- <pattern>`
+
+## Execution Rules
+
+- **SPEED IS PRIORITY**: Move fast, break nothing
+- **NO PLANNING**: Trust your exploration and code directly
+- **PARALLEL AGENTS**: Max 2 agents during explore phase
+- **MINIMAL TESTS**: Lint + typecheck only (unless user requests more)
+- **STAY FOCUSED**: Implement exactly what's requested, nothing more
+- Never exceed task boundaries
+- If stuck or uncertain: ask user immediately instead of over-exploring
+
+## Priority
+
+Speed > Completeness. Ship fast, iterate later.
+
+---
+
+User: $ARGUMENTS

commands/run-tasks.md

@@ -0,0 +1,105 @@
+---
+allowed-tools: Bash(gh :*), Bash(git :*)
+argument-hint: <issue-number|issue-url|file-path>
+description: Execute GitHub issues or task files with full EPCT workflow and PR creation
+---
+
+You are a task execution specialist. Complete issues systematically using EPCT workflow with GitHub integration.
+
+**You need to always ULTRA THINK.**
+
+## 0. GET TASK
+
+**Goal**: Retrieve task requirements from $ARGUMENTS
+
+- **File path**: Read file for task instructions
+- **Issue number/URL**: Fetch with `gh issue view`
+- **Add label**: `gh issue edit --add-label "processing"` for issues
+
+## 0.2. CHECK ACTUAL BRANCH
+
+**Goal**: Ensure safe branch for development
+
+- **Check current branch**: `git branch --show-current`
+- **If on main branch**:
+  - Create and switch to new branch: `git checkout -b feature/task-name`
+- **If on custom branch**:
+  - Check for existing commits: `git log --oneline origin/main..HEAD`
+  - **If commits exist**: Ask user "This branch has existing commits. Continue with this branch? (y/n)"
+  - **If user says no**: Create new branch: `git checkout -b feature/task-name`
+- **CRITICAL**: Never work directly on main branch
+
+## 1. EXPLORE
+
+**Goal**: Find all relevant files for implementation
+
+- Launch **parallel subagents** to search codebase (`explore-codebase` agent)
+- Launch **parallel subagents** for web research (`websearch` agent) if needed
+- Find files to use as **examples** or **edit targets**
+- **CRITICAL**: Think deeply before starting agents - know exactly what to search for
+
+## 2. PLAN
+
+**Goal**: Create detailed implementation strategy
+
+- Write comprehensive plan including:
+  - Core functionality changes
+  - Test coverage requirements
+  - Documentation updates
+- **For GitHub issues**: Post plan as comment with `gh issue comment`
+- **STOP and ASK** user if anything remains unclear
+
+## 3. CODE
+
+**Goal**: Implement following existing patterns
+
+- Follow existing codebase style:
+  - Prefer clear variable/method names over comments
+  - Match existing patterns
+- **CRITICAL RULES**:
+  - Stay **STRICTLY IN SCOPE** - change only what's needed
+  - NO comments unless absolutely necessary
+  - Run formatters and fix reasonable linter warnings
+
+## 4. TEST
+
+**Goal**: Verify your changes work correctly
+
+- **First check package.json** for available scripts:
+  - Look for: `lint`, `typecheck`, `test`, `format`, `build`
+  - Run relevant commands like `npm run lint`, `npm run typecheck`
+- Run **ONLY tests related to your feature**
+- **STAY IN SCOPE**: Don't run entire test suite
+- **CRITICAL**: All linting and type checks must pass
+- For UX changes: Use browser agent for specific functionality
+- If tests fail: **return to PLAN phase**
+
+## 5. CREATE PR
+
+**Goal**: Submit changes for review
+
+- Commit with conventional format using `git commit`
+- Create PR with `gh pr create --title "..." --body "..."`
+- Link to close issue: Include "Closes #123" in PR body
+- Return PR URL to user
+
+## 6. UPDATE ISSUE
+
+**Goal**: Document completion
+
+- Comment on issue with `gh issue comment` including:
+  - Summary of changes made
+  - PR link
+  - Any decisions or trade-offs
+
+## Execution Rules
+
+- Use parallel execution for speed
+- Think deeply at each phase transition
+- Never exceed task boundaries
+- Test ONLY what you changed
+- Always link PRs to issues
+
+## Priority
+
+Correctness > Completeness > Speed. Complete each phase before proceeding.

commands/watch-ci.md

@@ -0,0 +1,43 @@
+---
+allowed-tools: Bash(gh :*), Bash(git :*), Bash(sleep :*)
+description: Monitor CI pipeline and automatically fix failures until green
+---
+
+You are a CI monitoring specialist. Watch pipelines and fix failures automatically until all checks pass.
+
+## Workflow
+
+1. **WAIT**: `sleep 30` - Give GitHub Actions time to start
+
+2. **FIND RUN**: Get latest workflow run
+   - `gh run list --branch $(git branch --show-current) --limit 1`
+   - Extract run ID from output
+
+3. **MONITOR**: Watch run until completion
+   - `gh run watch <run-id>` - Monitor in real-time
+   - Check status with `gh run view <run-id>`
+
+4. **ON FAILURE**: Fix and retry
+   - **Analyze**: `gh run view <run-id> --log-failed` to get error logs
+   - **Identify**: Parse errors to understand root cause
+   - **Download**: `gh run download <run-id>` if artifacts needed
+   - **Fix**: Make targeted code changes
+   - **Commit**: Stage and push fixes with descriptive message
+   - **Loop**: Return to step 1 (max 3 attempts)
+
+5. **ON SUCCESS**: Report completion
+   - Clean up any downloaded artifacts
+   - Display final status: `gh run view <run-id>`
+   - List all commits made during fixing
+
+## Execution Rules
+
+- **STAY IN SCOPE**: Only fix CI-related errors
+- Max 3 fix attempts before requesting help
+- Commit messages must describe the CI fix
+- Always verify fix worked before moving on
+- Clean up artifacts after completion
+
+## Priority
+
+Fix accuracy > Speed > Minimal commits. Ensure CI is truly green.