create-claude-webapp 1.0.0 → 1.0.1

package/.claude/commands/reverse-engineer.md

@@ -0,0 +1,301 @@
+---
+name: reverse-engineer
+description: Generate PRD and Design Docs from existing codebase through discovery, generation, verification, and review workflow
+---
+
+**Command Context**: Reverse engineering workflow to create documentation from existing code
+
+Target: $ARGUMENTS
+
+**TodoWrite**: Register phases first, then steps within each phase as you enter it.
+
+## Step 0: Initial Configuration
+
+### 0.1 Scope Confirmation
+
+Use AskUserQuestion to confirm:
+1. **Target path**: Which directory/module to document
+2. **Depth**: PRD only, or PRD + Design Docs
+3. **Reference Architecture**: layered / mvc / clean / hexagonal / none
+4. **Human review**: Yes (recommended) / No (fully autonomous)
+
+### 0.2 Output Configuration
+
+- PRD output: `docs/prd/` or existing PRD directory
+- Design Doc output: `docs/design/` or existing design directory
+- Verify directories exist, create if needed
+
+## Workflow Overview
+
+```
+Phase 1: PRD Generation
+  Step 1: Scope Discovery (all units)
+  Step 2-5: Per-unit loop (Generation → Verification → Review → Revision)
+
+Phase 2: Design Doc Generation (if requested)
+  Step 6: Scope Discovery (all components per PRD)
+  Step 7-10: Per-component loop (Generation → Verification → Review → Revision)
+```
+
+**Context Passing**: Pass structured JSON output between steps. Use `$STEP_N_OUTPUT` placeholder notation.
+
+## Phase 1: PRD Generation
+
+**Register in TodoWrite**:
+- Step 1: PRD Scope Discovery
+- Per-unit processing (Steps 2-5 for each unit)
+
+### Step 1: PRD Scope Discovery
+
+**Task invocation**:
+```
+subagent_type: scope-discoverer
+prompt: |
+  Discover PRD targets in the codebase.
+
+  scope_type: prd
+  target_path: $USER_TARGET_PATH
+  reference_architecture: $USER_RA_CHOICE
+  focus_area: $USER_FOCUS_AREA (if specified)
+```
+
+**Store output as**: `$STEP_1_OUTPUT`
+
+**Quality Gate**:
+- At least one PRD unit discovered → proceed
+- No units discovered → ask user for hints
+
+**Human Review Point** (if enabled): Present discovered units for confirmation.
+
+### Step 2-5: Per-Unit Processing
+
+**Complete Steps 2→3→4→5 for each unit before proceeding to the next unit.**
+
+#### Step 2: PRD Generation
+
+**Task invocation**:
+```
+subagent_type: prd-creator
+prompt: |
+  Create reverse-engineered PRD for the following feature.
+
+  Operation Mode: reverse-engineer
+  External Scope Provided: true
+
+  Feature: $UNIT_NAME (from $STEP_1_OUTPUT)
+  Description: $UNIT_DESCRIPTION
+  Related Files: $UNIT_RELATED_FILES
+  Entry Points: $UNIT_ENTRY_POINTS
+
+  Skip independent scope discovery. Use provided scope data.
+  Create final version PRD based on code investigation within specified scope.
+```
+
+**Store output as**: `$STEP_2_OUTPUT` (PRD path)
+
+#### Step 3: Code Verification
+
+**Task invocation**:
+```
+subagent_type: code-verifier
+prompt: |
+  Verify consistency between PRD and code implementation.
+
+  doc_type: prd
+  document_path: $STEP_2_OUTPUT
+  code_paths: $UNIT_RELATED_FILES (from $STEP_1_OUTPUT)
+  verbose: false
+```
+
+**Store output as**: `$STEP_3_OUTPUT`
+
+**Quality Gate**:
+- consistencyScore >= 70 → proceed to review
+- consistencyScore < 70 → flag for detailed review
+
+#### Step 4: Review
+
+**Required Input**: $STEP_3_OUTPUT (verification JSON from Step 3)
+
+**Task invocation**:
+```
+subagent_type: document-reviewer
+prompt: |
+  Review the following PRD considering code verification findings.
+
+  doc_type: PRD
+  target: $STEP_2_OUTPUT
+  mode: composite
+
+  ## Code Verification Results
+  $STEP_3_OUTPUT
+
+  ## Additional Review Focus
+  - Alignment between PRD claims and verification evidence
+  - Resolution recommendations for each discrepancy
+  - Completeness of undocumented feature coverage
+```
+
+**Store output as**: `$STEP_4_OUTPUT`
+
+#### Step 5: Revision (conditional)
+
+**Trigger Conditions** (any one of the following):
+- Review status is "Needs Revision" or "Rejected"
+- Critical discrepancies exist in `$STEP_3_OUTPUT`
+- consistencyScore < 70
+
+**Task invocation**:
+```
+subagent_type: prd-creator
+prompt: |
+  Update PRD based on review feedback.
+
+  Operation Mode: update
+  Existing PRD: $STEP_2_OUTPUT
+
+  ## Review Feedback
+  $STEP_4_OUTPUT
+
+  ## Discrepancies to Address
+  (Extract critical and major discrepancies from $STEP_3_OUTPUT)
+
+  Apply corrections and improvements.
+```
+
+**Loop Control**: Maximum 2 revision cycles. After 2 cycles, flag for human review regardless of status.
+
+#### Unit Completion
+
+- [ ] Review status is "Approved" or "Approved with Conditions"
+- [ ] Human review passed (if enabled in Step 0)
+
+**Next**: Proceed to next unit. After all units → Phase 2.
+
+## Phase 2: Design Doc Generation
+
+*Execute only if Design Docs were requested in Step 0*
+
+**Register in TodoWrite**:
+- Step 6: Design Doc Scope Discovery
+- Per-component processing (Steps 7-10 for each component)
+
+### Step 6: Design Doc Scope Discovery
+
+For each approved PRD:
+
+**Task invocation**:
+```
+subagent_type: scope-discoverer
+prompt: |
+  Discover Design Doc targets within PRD scope.
+
+  scope_type: design-doc
+  existing_prd: $APPROVED_PRD_PATH
+  target_path: $PRD_RELATED_PATHS
+  reference_architecture: $USER_RA_CHOICE
+```
+
+**Store output as**: `$STEP_6_OUTPUT`
+
+**Quality Gate**:
+- At least one component discovered → proceed
+- No components → ask user for hints
+
+### Step 7-10: Per-Component Processing
+
+**Complete Steps 7→8→9→10 for each component before proceeding to the next component.**
+
+#### Step 7: Design Doc Generation
+
+**Task invocation**:
+```
+subagent_type: technical-designer
+prompt: |
+  Create Design Doc for the following component based on existing code.
+
+  Operation Mode: create
+
+  Component: $COMPONENT_NAME (from $STEP_6_OUTPUT)
+  Responsibility: $COMPONENT_RESPONSIBILITY
+  Primary Files: $COMPONENT_PRIMARY_FILES
+  Public Interfaces: $COMPONENT_PUBLIC_INTERFACES
+  Dependencies: $COMPONENT_DEPENDENCIES
+
+  Parent PRD: $APPROVED_PRD_PATH
+
+  Document current architecture. Do not propose changes.
+```
+
+**Store output as**: `$STEP_7_OUTPUT`
+
+#### Step 8: Code Verification
+
+**Task invocation**:
+```
+subagent_type: code-verifier
+prompt: |
+  Verify consistency between Design Doc and code implementation.
+
+  doc_type: design-doc
+  document_path: $STEP_7_OUTPUT
+  code_paths: $COMPONENT_PRIMARY_FILES
+  verbose: false
+```
+
+**Store output as**: `$STEP_8_OUTPUT`
+
+#### Step 9: Review
+
+**Required Input**: $STEP_8_OUTPUT (verification JSON from Step 8)
+
+**Task invocation**:
+```
+subagent_type: document-reviewer
+prompt: |
+  Review the following Design Doc considering code verification findings.
+
+  doc_type: DesignDoc
+  target: $STEP_7_OUTPUT
+  mode: composite
+
+  ## Code Verification Results
+  $STEP_8_OUTPUT
+
+  ## Parent PRD
+  $APPROVED_PRD_PATH
+
+  ## Additional Review Focus
+  - Technical accuracy of documented interfaces
+  - Consistency with parent PRD scope
+  - Completeness of component boundary definitions
+```
+
+**Store output as**: `$STEP_9_OUTPUT`
+
+#### Step 10: Revision (conditional)
+
+Same logic as Step 5, using technical-designer with update mode.
+
+#### Component Completion
+
+- [ ] Review status is "Approved" or "Approved with Conditions"
+- [ ] Human review passed (if enabled in Step 0)
+
+**Next**: Proceed to next component. After all components → Final Report.
+
+## Final Report
+
+Output summary including:
+- Generated documents table (Type, Name, Consistency Score, Review Status)
+- Action items (critical discrepancies, undocumented features, flagged items)
+- Next steps checklist
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Discovery finds nothing | Ask user for project structure hints |
+| Generation fails | Log failure, continue with other units, report in summary |
+| consistencyScore < 50 | Flag for mandatory human review, do not auto-approve |
+| Review rejects after 2 revisions | Stop loop, flag for human intervention |

package/.claude/commands/review.md

@@ -0,0 +1,88 @@
+---
+description: Design Doc compliance validation with optional auto-fixes
+---
+
+**Command Context**: Post-implementation quality assurance command
+
+## Execution Method
+
+- Compliance validation → performed by code-reviewer
+- Rule analysis → performed by rule-advisor
+- Fix implementation → performed by task-executor
+- Quality checks → performed by quality-fixer
+- Re-validation → performed by code-reviewer
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+Design Doc (uses most recent if omitted): $ARGUMENTS
+
+**Think deeply** Understand the essence of compliance validation and execute:
+
+## Execution Flow
+
+### 1. Prerequisite Check
+```bash
+# Identify Design Doc
+ls docs/design/*.md | grep -v template | tail -1
+
+# Check implementation files
+git diff --name-only main...HEAD
+```
+
+### 2. Execute code-reviewer
+Validate Design Doc compliance:
+- Acceptance criteria fulfillment
+- Code quality check
+- Implementation completeness assessment
+
+### 3. Verdict and Response
+
+**Criteria (considering project stage)**:
+- Prototype: Pass at 70%+
+- Production: 90%+ recommended
+- Critical items (security, etc.): Required regardless of rate
+
+**Compliance-based response**:
+
+For low compliance (production <90%):
+```
+Validation Result: [X]% compliance
+Unfulfilled items:
+- [item list]
+
+Execute fixes? (y/n): 
+```
+
+If user selects `y`:
+
+## Pre-fix Metacognition
+**Required**: `rule-advisor → TodoWrite → task-executor → quality-fixer`
+
+1. **Execute rule-advisor**: Understand fix essence (symptomatic treatment vs root solution)
+2. **Update TodoWrite**: Register work steps. Always include: first "Confirm skill constraints", final "Verify skill fidelity". Create task file following task template (see documentation-criteria skill) -> `docs/plans/tasks/review-fixes-YYYYMMDD.md`
+3. **Execute task-executor**: Staged auto-fixes (stops at 5 files)
+4. **Execute quality-fixer**: Confirm quality gate passage
+5. **Re-validate**: Measure improvement with code-reviewer
+
+### 4. Final Report
+```
+Initial compliance: [X]%
+Final compliance: [Y]% (if fixes executed)
+Improvement: [Y-X]%
+
+Remaining issues:
+- [items requiring manual intervention]
+```
+
+## Auto-fixable Items
+- Simple unimplemented acceptance criteria
+- Error handling additions
+- Type definition fixes
+- Function splitting (length/complexity improvements)
+
+## Non-fixable Items
+- Fundamental business logic changes
+- Architecture-level modifications
+- Design Doc deficiencies
+
+**Scope**: Design Doc compliance validation and auto-fixes.

package/.claude/commands/setup-auth.md

@@ -0,0 +1,68 @@
+---
+description: Initialize Stack-auth integration
+---
+
+Initialize Stack-auth for authentication following the stack-auth skill.
+
+## Prerequisites Check
+
+```bash
+# Check if @stackframe/stack is installed
+! grep "@stackframe/stack" package.json || echo "⚠️ Stack-auth not installed"
+```
+
+## Initialization Steps
+
+### 1. Install Dependencies
+```bash
+npm install @stackframe/stack
+```
+
+### 2. Create Stack-auth Configuration
+Create `lib/stack.ts` with:
+- StackServerApp configuration
+- Environment variable references
+
+### 3. Configure Provider
+Update `app/layout.tsx`:
+- Add StackProvider
+- Add StackTheme wrapper
+
+### 4. Set Environment Variables
+Add to `.env.local`:
+```env
+NEXT_PUBLIC_STACK_PROJECT_ID=
+NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY=
+STACK_SECRET_SERVER_KEY=
+```
+
+Guide user to get credentials from Stack-auth dashboard.
+
+### 5. Create Auth Components
+Generate basic components:
+- Sign-in form
+- Sign-up form
+- OAuth buttons
+- Sign-out button
+
+### 6. Create Auth Routes
+Set up auth pages:
+- `/sign-in`
+- `/sign-up`
+- `/sign-out`
+
+### 7. Configure Middleware
+Create/update `middleware.ts` for route protection.
+
+## Verification
+- [ ] Dependencies installed
+- [ ] Provider configured
+- [ ] Environment variables set
+- [ ] Auth routes accessible
+- [ ] Can sign in/out
+
+## Output
+Report setup status with:
+- Configured components
+- Auth routes
+- Next steps for OAuth providers

package/.claude/commands/setup-supabase.md

@@ -0,0 +1,66 @@
+---
+description: Initialize Supabase in project
+---
+
+Initialize Supabase for the project following the supabase and supabase-local skills.
+
+## Prerequisites Check
+
+```bash
+# Check if Supabase CLI is installed
+! which supabase || echo "⚠️ Supabase CLI not installed. Install: brew install supabase/tap/supabase"
+
+# Check if Docker is running
+! docker info > /dev/null 2>&1 || echo "⚠️ Docker is not running"
+```
+
+## Initialization Steps
+
+### 1. Initialize Supabase
+```bash
+# Initialize Supabase in project root
+supabase init
+```
+
+### 2. Configure Local Settings
+Review and customize `supabase/config.toml`:
+- Set appropriate ports
+- Configure auth settings
+- Enable/disable services as needed
+
+### 3. Create Initial Migration
+```bash
+# Create users table migration
+supabase migration new create_users_table
+```
+
+Provide migration template following supabase skill:
+- UUID primary key
+- created_at, updated_at timestamps
+- RLS enabled
+- Appropriate policies
+
+### 4. Start Local Supabase
+```bash
+supabase start
+```
+
+### 5. Generate Types
+```bash
+supabase gen types typescript --local > src/types/database.types.ts
+```
+
+### 6. Environment Setup
+Create `.env.local` with output from `supabase start`:
+- NEXT_PUBLIC_SUPABASE_URL
+- NEXT_PUBLIC_SUPABASE_ANON_KEY
+- SUPABASE_SERVICE_ROLE_KEY
+
+## Verification
+- [ ] `supabase status` shows all services running
+- [ ] Can access Studio at http://127.0.0.1:54323
+- [ ] Types generated successfully
+- [ ] Environment variables set
+
+## Output
+Report initialization status and next steps for connecting to the application.

package/.claude/commands/setup-vercel.md

@@ -0,0 +1,71 @@
+---
+description: Initialize Vercel configuration
+---
+
+Initialize Vercel for deployment following the vercel-deployment skill.
+
+## Prerequisites Check
+
+```bash
+# Check if Vercel CLI is installed
+! which vercel || echo "⚠️ Vercel CLI not installed. Install: npm i -g vercel"
+
+# Check if logged in
+! vercel whoami || echo "⚠️ Not logged in. Run: vercel login"
+```
+
+## Initialization Steps
+
+### 1. Link Project
+```bash
+vercel link
+```
+
+Follow prompts to:
+- Select or create project
+- Confirm settings
+
+### 2. Create vercel.json
+Create configuration file with appropriate settings:
+- Framework detection
+- Build commands
+- Function configuration
+- Headers and redirects
+
+### 3. Set Environment Variables
+```bash
+# Pull existing env vars (if any)
+vercel env pull .env.local
+
+# Add required variables
+vercel env add NEXT_PUBLIC_SUPABASE_URL
+vercel env add NEXT_PUBLIC_SUPABASE_ANON_KEY
+vercel env add SUPABASE_SERVICE_ROLE_KEY
+```
+
+### 4. Configure Build Settings
+Verify in Vercel dashboard or vercel.json:
+- Build command: `npm run build`
+- Output directory: `.next`
+- Install command: `npm ci`
+
+### 5. Test Deployment
+```bash
+# Deploy preview
+vercel
+
+# Verify deployment
+vercel inspect [deployment-url]
+```
+
+## Verification
+- [ ] Project linked successfully
+- [ ] vercel.json created
+- [ ] Environment variables configured
+- [ ] Preview deployment successful
+
+## Output
+Report setup status with:
+- Project URL
+- Dashboard link
+- Next steps for production deployment

package/.claude/commands/sync-skills.md

@@ -0,0 +1,116 @@
+---
+description: Synchronize skill metadata and optimize rule-advisor precision after skill edits
+---
+
+**Command Context**: Post-editing maintenance workflow for skill files
+
+**Think deeply** Maximize rule-advisor execution precision through systematic synchronization:
+
+## Execution Flow
+
+### 1. Scan Skill Files
+```bash
+# Runtime skills directory
+SKILLS_DIR=".claude/skills"
+INDEX_FILE=".claude/skills/task-analyzer/references/skills-index.yaml"
+
+# Analyze all skill files
+find "${SKILLS_DIR}" -name "SKILL.md" -type f | sort
+```
+
+### 2. Synchronize and Optimize Metadata
+
+#### Automatic Section Synchronization
+- Extract `## ` sections from each SKILL.md
+- Update sections in skills-index.yaml automatically
+
+#### Tag Optimization
+- Analyze file content for relevant keywords
+- Propose addition of missing tags
+- Suggest removal of obsolete tags
+
+#### Typical-Use Enhancement
+- Infer usage scenarios from file changes
+- Propose more specific and actionable descriptions
+
+#### Key-References Completion
+- Detect newly introduced concepts or methodologies
+- Suggest relevant reference additions
+
+### 3. Rule-Advisor Precision Optimization
+
+Enhance metadata quality to enable accurate skill selection by rule-advisor:
+
+```
+=== Skill Metadata Synchronization ===
+Target: .claude/skills
+
+Updates executed:
+✅ Sections synchronized
+  - typescript-testing: 2 sections added
+  - coding-standards: 1 section updated
+
+✅ Tags optimized
+  - typescript-rules: Suggest adding [functional-programming]
+  - technical-spec: Suggest removing [deprecated]
+
+✅ Typical-use improved
+  - 3 skills updated with more specific descriptions
+
+Final result: Rule-advisor precision optimization complete
+```
+
+## 🧠 Metacognitive Points
+
+**Essential Purpose**:
+- Not mere consistency maintenance, but rule-advisor selection accuracy enhancement
+- Metadata optimization as the final step of skill editing workflow
+
+**Quality Criteria**:
+- Sections must achieve 100% synchronization
+- Tags must accurately reflect content
+- Typical-use must specify concrete usage scenarios
+- Key-references must cover current methodologies
+
+## Change Necessity Evaluation
+
+**EVALUATION SEQUENCE**:
+- IF sections achieve 100% synchronization → OUTPUT "Synchronization verified. No updates required." THEN TERMINATE
+- IF content-to-tag mapping shows zero mismatches → DETERMINE no_changes_needed = true THEN TERMINATE
+- IF AND ONLY IF measurable improvements exist → GENERATE specific modification proposals WITH exact before/after values
+
+**NOTE**: You MUST NOT force changes. When no improvements are detected, you SHALL report "No modifications necessary" and STOP execution.
+
+## Execution Timing
+
+- After skill file edits (mandatory)
+- When adding new skill files
+- After major skill revisions
+- When rule-advisor selection accuracy appears degraded
+
+## Example Output
+
+```
+=== Skill Metadata Synchronization Started ===
+Target: .claude/skills (13 skills)
+
+[1/13] typescript-rules
+  ✅ sections: 7 synchronized
+  💡 tags proposed: +[functional-programming, dependency-injection]
+  💡 typical-use: "General TypeScript implementation" → "Type-safe implementation with modern TypeScript features"
+
+[2/13] typescript-testing
+  ✅ sections: 2 added (Test Granularity Principles, Mock Type Safety Enforcement)
+  ✅ tags: No changes needed
+  ✅ typical-use: Maintained
+
+...
+
+=== Synchronization Complete ===
+Updated: 3 skills
+Proposals: 5 items (approval required)
+
+Rule-advisor precision improvement: Estimated 15% enhancement
+```
+
+**Scope**: Post-edit skill metadata synchronization and rule-advisor precision optimization.