create-claude-webapp 1.0.0 → 1.0.1

package/.claude/commands/implement.md

@@ -0,0 +1,80 @@
+---
+description: Orchestrate the complete implementation lifecycle from requirements to deployment
+---
+
+**Command Context**: Full-cycle implementation management (Requirements Analysis → Design → Planning → Implementation → Quality Assurance)
+
+Strictly adhere to subagents-orchestration-guide skill and operate as an orchestrator.
+
+## Execution Decision Flow
+
+### 1. Current Situation Assessment
+Instruction Content: $ARGUMENTS
+
+**Think deeply** Assess the current situation:
+
+| Situation Pattern | Decision Criteria | Next Action |
+|------------------|------------------|-------------|
+| New Requirements | No existing work, new feature/fix request | Start with requirement-analyzer |
+| Flow Continuation | Existing docs/tasks present, continuation directive | Identify next step in subagents-orchestration-guide skill flow |
+| Quality Errors | Error detection, test failures, build errors | Execute quality-fixer |
+| Ambiguous | Intent unclear, multiple interpretations possible | Confirm with user |
+
+### 2. Progress Verification for Continuation
+When continuing existing flow, verify:
+- Latest artifacts (PRD/ADR/Design Doc/Work Plan/Tasks)
+- Current phase position (Requirements/Design/Planning/Implementation/QA)
+- Identify next step in subagents-orchestration-guide skill corresponding flow
+
+### 3. After requirement-analyzer [Stop]
+
+When user responds to questions:
+- If response matches any `scopeDependencies.question` → Check `impact` for scale change
+- If scale changes → Re-execute requirement-analyzer with updated context
+- If `confidence: "confirmed"` or no scale change → Proceed to next step
+
+### 4. After Scale Determination: Register All Flow Steps to TodoWrite (Required)
+
+After scale determination, **register all steps of the applicable subagents-orchestration-guide skill flow to TodoWrite**. Always include: first "Confirm skill constraints", final "Verify skill fidelity". After registration, proceed through the flow referencing TodoWrite.
+
+### 5. Execute Next Action
+
+**Execute the next pending task in TodoWrite**.
+
+## 📋 subagents-orchestration-guide skill Compliance Execution
+
+**Pre-execution Checklist (Required)**:
+- [ ] Confirmed relevant subagents-orchestration-guide skill flow
+- [ ] Identified current progress position
+- [ ] Clarified next step
+- [ ] Recognized stopping points → **Use AskUserQuestion for confirmation at all Stop points**
+- [ ] Understood the 4-step cycle after task execution (task-executor → escalation judgment/follow-up → quality-fixer → commit)
+
+**Flow Adherence**: Follow "Autonomous Execution Task Management" in subagents-orchestration-guide skill, managing 4 steps with TodoWrite
+
+## 🚨 Sub-agent Invocation Constraints
+
+Include the following at the end of prompts when invoking sub-agents, as rule-advisor invocation from sub-agents causes system crash:
+```
+[Constraint] rule-advisor can only be used by Main AI
+```
+
+## 🎯 Mandatory Orchestrator Responsibilities
+
+### Task Execution Flow
+Following "Autonomous Execution Task Management" in subagents-orchestration-guide skill, manage these 4 steps with TodoWrite:
+1. task-executor execution
+2. Escalation judgment and follow-up
+3. quality-fixer execution
+4. git commit
+
+### Test Information Communication
+After acceptance-test-generator execution, when calling work-planner, communicate:
+- Generated integration test file path
+- Generated E2E test file path
+- Explicit note that integration tests run with implementation, E2E tests run after all implementations
+
+## Execution Method
+
+All work is executed through sub-agents.
+Sub-agent selection follows subagents-orchestration-guide skill.

package/.claude/commands/local-dev.md

@@ -0,0 +1,94 @@
+---
+description: Start local development environment
+---
+
+Start the local development environment with all services.
+
+## Service Startup
+
+### 1. Start Supabase
+```bash
+supabase start
+```
+
+Wait for all services to be ready.
+
+### 2. Verify Supabase
+```bash
+supabase status
+```
+
+Confirm:
+- API URL: http://127.0.0.1:54321
+- Studio URL: http://127.0.0.1:54323
+- Inbucket URL: http://127.0.0.1:54324
+
+### 3. Environment Check
+Verify `.env.local` has correct local values:
+```env
+NEXT_PUBLIC_SUPABASE_URL=http://127.0.0.1:54321
+NEXT_PUBLIC_SUPABASE_ANON_KEY=<from supabase start>
+SUPABASE_SERVICE_ROLE_KEY=<from supabase start>
+```
+
+### 4. Apply Migrations
+```bash
+supabase db reset
+```
+
+### 5. Generate Types
+```bash
+supabase gen types typescript --local > src/types/database.types.ts
+```
+
+### 6. Start Development Server
+```bash
+npm run dev
+```
+
+## Service URLs
+
+| Service | URL |
+|---------|-----|
+| Application | http://localhost:3000 |
+| Supabase API | http://127.0.0.1:54321 |
+| Supabase Studio | http://127.0.0.1:54323 |
+| Inbucket (Email) | http://127.0.0.1:54324 |
+
+## Stopping Services
+
+### Stop All
+```bash
+# Stop Supabase (preserves data)
+supabase stop
+
+# Stop Supabase and clear data
+supabase stop --no-backup
+
+# Stop Next.js dev server
+Ctrl+C
+```
+
+## Troubleshooting
+
+### Port Conflicts
+```bash
+# Check what's using a port
+lsof -i :54321
+```
+
+### Docker Issues
+```bash
+# Restart Docker
+# Then restart Supabase
+supabase stop --no-backup
+supabase start
+```
+
+### Database Reset
+```bash
+supabase db reset
+```
+
+## Output
+Report local environment status with all service URLs.

package/.claude/commands/plan.md

@@ -0,0 +1,61 @@
+---
+description: Create work plan from design document and obtain plan approval
+---
+
+**Command Context**: This command is dedicated to the planning phase.
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+**Execution Protocol**:
+1. **Delegate all work** to sub-agents (NEVER create plans yourself)
+2. **Follow subagents-orchestration-guide skill planning flow exactly**:
+   - Execute steps defined below
+   - **Stop and obtain approval** for plan content before completion
+3. **Scope**: Complete when work plan receives approval
+
+**CRITICAL**: NEVER skip acceptance-test-generator when user requests test generation.
+
+## Scope Boundaries
+
+**Included in this command**:
+- Design document selection
+- E2E test skeleton generation (optional, with user confirmation)
+- Work plan creation with work-planner
+- Plan approval obtainment
+
+**Responsibility Boundary**: This command completes with work plan approval.
+
+Follow subagents-orchestration-guide skill strictly and create work plan with the following process:
+
+## Execution Process
+
+1. **Design Document Selection**
+   ! ls -la docs/design/*.md | head -10
+   - Check for existence of design documents, notify user if none exist
+   - Present options if multiple exist (can be specified with $ARGUMENTS)
+
+2. **E2E Test Skeleton Generation Confirmation**
+   - Confirm with user whether to generate E2E test skeleton first
+   - If user wants generation: Generate test skeleton with acceptance-test-generator
+   - Pass generation results to next process according to subagents-orchestration-guide skill coordination specification
+
+3. **Work Plan Creation**
+   - Create work plan with work-planner
+   - Utilize deliverables from previous process according to subagents-orchestration-guide skill coordination specification
+   - Interact with user to complete plan and obtain approval for plan content
+
+**Think deeply** Create a work plan from the selected design document, clarifying specific implementation steps and risks.
+
+**Scope**: Up to work plan creation and obtaining approval for plan content.
+
+## Response at Completion
+✅ **REQUIRED**: End with the following standard response after plan content approval
+```
+Planning phase completed.
+- Work plan: docs/plans/[plan-name].md
+- Status: Approved
+
+Please provide separate instructions for implementation.
+```

package/.claude/commands/project-inject.md

@@ -0,0 +1,76 @@
+---
+description: Inject project-specific context into project-context.md
+---
+
+**Command Context**: When using the boilerplate, collect project-specific context and update project-context.md.
+
+## Execution Process
+
+### 1. Current State Verification
+! ls -la .claude/skills/project-context/SKILL.md
+! cat package.json | grep -E '"name":|"description":'
+
+### 2. Project Context Collection
+
+Interact with the user to collect the following information:
+
+```
+【Core Project Information】
+1. What problem does your project solve?
+   Examples: "Manual time tracking is inefficient" "Inventory management is person-dependent"
+
+2. Who is the system for?
+   Examples: "50-member sales team" "E-commerce site operators"
+
+3. In what situations will it be used?
+   Examples: "Field staff entering daily reports" "Month-end aggregation tasks"
+
+【Development Structure】
+- Individual development / Team development (number of members)
+- Development phase (Prototype / Production development / In operation)
+
+【Critical Business Constraints】(Maximum 3)
+Examples: "7-year audit log retention" "Mandatory approval workflow" "Real-time synchronization"
+```
+
+**Think deeply** From the collected information, understand the project's essence and construct context focused on single responsibility.
+
+### 3. Generate project-context.md
+
+## AI Execution Accuracy Maximization Criteria
+
+Generated project-context.md must follow these criteria:
+
+### Principles of Description
+1. **Minimal yet maximally efficient**: Essential information only, eliminate redundancy
+2. **AI-decidable**: Use only measurable and verifiable criteria ("quickly" → "within 5 seconds")
+3. **Eliminate ambiguity**: Include specific numbers, conditions, and examples
+4. **Preferred format**: Describe in "do this" form rather than "don't do that"
+
+### Responsibility Boundaries
+project-context.md's single responsibility is "project-specific contextual information" only:
+- ✅ Include: Project objectives, target users, business constraints
+- ❌ Exclude: Tech stack (→technical-spec skill), implementation principles (→typescript-rules skill), architecture (→technical-spec skill)
+
+### Structure
+```markdown
+# Project Context
+
+## Project Overview
+- **Problem being solved**: [Specific challenge]
+- **Target users**: [Include number and attributes]
+- **Usage scenarios**: [Specific situations]
+
+## Development Structure
+- **Team composition**: [Number and roles]
+- **Development phase**: [Current stage]
+
+## Business Constraints
+1. [Measurable constraint]
+2. [Verifiable requirement]
+```
+
+### 4. Update skills-index.yaml
+Update the typical-use in the project-context section to match the project.
+
+**Scope**: Update project-context skill only. Technology choices are the responsibility of other skills.

package/.claude/commands/refine-skill.md

@@ -0,0 +1,207 @@
+---
+description: Implement user skill change requests with maximum precision optimization
+---
+
+Change request: $ARGUMENTS
+
+**Think deeply** Extract the TRUE INTENT behind user's change request and implement with MAXIMUM PRECISION to eliminate ALL ambiguity:
+
+## 9 Optimization Perspectives
+1. Context efficiency vs execution accuracy - Maximum accuracy with minimal description
+2. Deduplication - Consistency within and across skill files
+3. Proper responsibility aggregation - Group related content (minimize read operations)
+4. Clear decision criteria - Measurable standards
+5. Transform negatives to recommendations - Recommended format (background: including NG examples)
+6. Consistent notation - Unified expressions
+7. Explicit prerequisites - Make implicit assumptions visible
+8. Optimized description order - Most important first, exceptions last
+9. Clear scope boundaries - What's covered vs what's not
+
+## Execution Flow
+
+### 1. Understand the Request
+
+Question template when unspecified:
+```
+1. Which skill to modify?
+   e.g.: typescript-rules / coding-standards / documentation-criteria
+
+2. Select change type:
+   a) Add new criteria (add new standards)
+   b) Modify existing criteria (clarify ambiguous descriptions)
+   c) Delete criteria (remove obsolete standards)
+
+3. Specific changes:
+   e.g.: "Add rule prohibiting 'any' type usage"
+   e.g.: "Clarify error handling criteria"
+   [User input]
+```
+
+### 2. Create Design Proposal
+
+Target file identification and current state check:
+
+```
+# Tool selection criteria (measurable decisions)
+if skill name is explicitly provided:
+  Read: .claude/skills/{skill-name}/SKILL.md direct read
+else if partial skill name known:
+  Glob: .claude/skills/*{keyword}*/SKILL.md search
+  Read: Check identified file's current state
+else:
+  Glob: .claude/skills/*/SKILL.md for full scan
+  Confirm target skill selection with user
+```
+
+Design template:
+```
+【Current】
+"Handle errors appropriately" (ambiguous: "appropriately" undefined)
+
+【Understanding User Request】
+"Want stricter error handling" → Set measurable criteria
+
+【Proposal】
+"Error handling implementation criteria:
+1. try-catch required for:
+   - External API calls (fetch, axios, etc.)
+   - File I/O operations (fs.readFile, etc.)
+   - Parsing operations (JSON.parse, parseInt, etc.)
+2. Required error log items:
+   - error.name (error type)
+   - error.stack (location)
+   - Timestamp (ISO 8601 format)
+3. User notification criteria:
+   - No technical details (NG: stack trace display)
+   - Clear action items (recommended: "Please try again")"
+
+Proceed with this design? (y/n)
+```
+
+### 3. Three-Pass Review Process
+
+#### Pass 1: Add for Maximum Accuracy【Addition-Only Mode】
+Declaration: "Pass 1: Addition mode execution. Deletions are prohibited."
+- Convert all ambiguous expressions → measurable criteria
+  Example: "large" → "100+ lines" "5+ files"
+- Make all implicit prerequisites explicit
+  Example: "In TypeScript environment" "Within async functions"
+- Define all exceptions and edge cases
+  Example: "When null/undefined" "For empty arrays"
+Report: Count added items (minimum 5 items)
+
+#### Pass 2: Critical Modification to Reduce Redundancy【Actual Modification Mode】
+Declaration: "Pass 2: Critical modification mode execution. Actually delete and consolidate redundant parts."
+
+Modification work:
+1. Critically review all Pass 1 additions
+2. Apply modifications using these criteria:
+   - Duplicate concepts → Consolidate
+   - Overly detailed explanations → Simplify
+   - Overlap with other skills → Replace with references
+3. Record complete before/after diff (deletion reasons required)
+
+Report format:
+```
+Modified locations: X items
+Deleted/consolidated content:
+- [Before]: "Detailed description"
+  [After]: "Concise description"
+  [Reason]: Redundancy elimination
+```
+
+#### Pass 3: Accuracy Assurance via Diff Evaluation【Restoration Decision Mode】
+Declaration: "Pass 3: Diff evaluation mode execution. Review all Pass 2 modifications and restore if accuracy compromised."
+
+Verification work:
+1. Evaluate each Pass 2 modification:
+   - Does deletion create implementation ambiguity? → Restore
+   - Are edge cases still covered? → Restore if missing
+2. Action mapping:
+   - Deletions with accuracy risks → Restore
+   - Valid deletions → Keep
+
+Final confirmation (required answer):
+"Are necessary and sufficient conditions present for accurate implementation of user requirements?"
+
+Report: Number of restored items and final reduction percentage
+
+### 4. Get Approval
+
+Present before/after comparison for user approval.
+
+### 5. Implementation
+
+1. Apply changes with appropriate tool (after user approval)
+2. Final verification with git diff
+3. Suggest `/sync-skills` execution
+
+## Decision Criteria Checklist
+- [ ] Expressible in "if-then" format ("if X then Y")
+- [ ] Measurable by numbers/counts/states (eliminate subjective judgment)
+- [ ] Related content aggregated in single file (minimize read operations)
+- [ ] Relationships with other skills specified (dependencies/references/delegation)
+- [ ] NG examples included as background information
+- [ ] All prerequisites explicitly stated
+
+## Reduction Pattern Examples
+| Pattern | Before | After |
+|---------|--------|-------|
+| Emotional expressions | "must always" | "execute when (background: build error if skipped)" |
+| Time expressions | "immediately" | "execute first after error detection" |
+| Implicit prerequisites | "implement error handling" | "TypeScript async function error handling" |
+| Unclear order | "consider: A, B, C" | "Priority: 1.A (required), 2.B (recommended), 3.C (optional)" |
+| Redundant explanation | "ensure type safety by defining types, checking types, and preventing type errors" | "type safety (define・check・prevent errors)" |
+| Ambiguous scope | "write tests" | "write unit tests (see typescript-testing skill for E2E tests)" |
+
+## Output Example
+
+```
+=== Change Implementation Complete ===
+
+【User Request】
+"Strengthen TypeScript error handling criteria"
+
+【Changes】
+Target: .claude/skills/typescript-rules/SKILL.md
+Section: ## Error Handling
+
+Before:
+"Handle errors appropriately"
+
+After (3-pass review complete):
+"Error handling implementation criteria:
+1. try-catch block required for:
+   - External API calls (fetch, axios, etc.)
+   - File I/O operations (fs.readFile, fs.writeFile, etc.)
+   - Exception-prone operations (JSON.parse, parseInt, etc.)
+2. Required error log items:
+   - error.name (error type)
+   - error.stack (location)
+   - new Date().toISOString() (timestamp)
+3. User-facing messages:
+   - No technical details (NG: stack trace display)
+   - Clear action items (recommended: "Please try again")"
+
+【Improvement Metrics】
+- Decision clarity: 0% → 100% (all measurable)
+- Ambiguous expressions: 1 → 0
+- NG examples included as background
+
+Run /sync-skills for metadata synchronization.
+```
+
+## Execution Order
+1. Understand user request
+2. Analyze current state
+3. Design changes with 9 perspectives
+4. 3-pass review process
+5. User approval
+6. Apply changes
+7. Suggest sync-skills
+
+**Scope**: Understanding user change requests and implementing with maximum accuracy
+
+## Error Handling
+- **Skill not found**: Display available skill list
+- **Large change detected**: Suggest phased implementation for 50%+ changes