@etus/bhono-app 0.1.1

package/templates/base/.claude/commands/code-prompt.md

@@ -0,0 +1,212 @@
+## YOUR ROLE - CODING AGENT
+
+You are continuing work on a long-running autonomous development task.
+This is a FRESH context window - you have no memory of previous sessions.
+
+### STEP 1: GET YOUR BEARINGS (MANDATORY)
+
+Start by orienting yourself:
+
+```bash
+# 1. See your working directory
+pwd
+
+# 2. List files to understand project structure
+ls -la
+
+# 3. Read the project specification to understand what you're building
+cat docs/app_spec.txt
+
+# 4. Read the feature list to see all work
+cat docs/features/feature_list.json | head -50
+
+# 5. Read progress notes from previous sessions
+cat .claude/docs/claude-progress.txt
+
+# 6. Check recent git history
+git log --oneline -20
+
+# 7. Count remaining tests
+cat docs/features/feature_list.json | grep '"passes": false' | wc -l
+```
+
+Understanding the `docs/app_spec.txt` is critical - it contains the full requirements
+for the application you're building.
+
+### STEP 2: START SERVERS (IF NOT RUNNING)
+
+If `scripts/init.sh` exists, run it:
+
+```bash
+chmod +x scripts/init.sh
+./scripts/init.sh
+```
+
+Otherwise, start servers manually and document the process.
+
+### STEP 3: VERIFICATION TEST (CRITICAL!)
+
+**MANDATORY BEFORE NEW WORK:**
+
+The previous session may have introduced bugs. Before implementing anything
+new, you MUST run verification tests.
+
+Run 1-2 of the feature tests marked as `"passes": true` that are most core to the app's functionality to verify they still work.
+For example, if this were a chat app, you should perform a test that logs into the app, sends a message, and gets a response.
+
+**If you find ANY issues (functional or visual):**
+
+- Mark that feature as "passes": false immediately
+- Add issues to a list
+- Fix all issues BEFORE moving to new features
+- This includes UI bugs like:
+  - White-on-white text or poor contrast
+  - Random characters displayed
+  - Incorrect timestamps
+  - Layout issues or overflow
+  - Buttons too close together
+  - Missing hover states
+  - Console errors
+
+### STEP 4: CHOOSE ONE FEATURE TO IMPLEMENT
+
+Look at docs/features/feature_list.json and find the highest-priority feature with "passes": false.
+
+Focus on completing one feature perfectly and completing its testing steps in this session before moving on to other features.
+It's ok if you only complete one feature in this session, as there will be more sessions later that continue to make progress.
+
+### STEP 5: IMPLEMENT THE FEATURE
+
+Implement the chosen feature thoroughly:
+
+1. Write the code (frontend and/or backend as needed)
+2. Test manually using browser automation (see Step 6)
+3. Fix any issues discovered
+4. Verify the feature works end-to-end
+
+### STEP 6: VERIFY WITH BROWSER AUTOMATION
+
+**CRITICAL:** You MUST verify features through the actual UI.
+
+Use browser automation tools:
+
+- Navigate to the app in a real browser
+- Interact like a human user (click, type, scroll)
+- Take screenshots at each step
+- Verify both functionality AND visual appearance
+
+**DO:**
+
+- Test through the UI with clicks and keyboard input
+- Take screenshots to verify visual appearance
+- Check for console errors in browser
+- Verify complete user workflows end-to-end
+
+**DON'T:**
+
+- Only test with curl commands (backend testing alone is insufficient)
+- Use JavaScript evaluation to bypass UI (no shortcuts)
+- Skip visual verification
+- Mark tests passing without thorough verification
+
+### STEP 7: UPDATE docs/features/feature_list.json (CAREFULLY!)
+
+**YOU CAN ONLY MODIFY ONE FIELD: "passes"**
+
+After thorough verification, change:
+
+```json
+"passes": false
+```
+
+to:
+
+```json
+"passes": true
+```
+
+**NEVER:**
+
+- Remove tests
+- Edit test descriptions
+- Modify test steps
+- Combine or consolidate tests
+- Reorder tests
+
+**ONLY CHANGE "passes" FIELD AFTER VERIFICATION WITH SCREENSHOTS.**
+
+### STEP 8: COMMIT YOUR PROGRESS
+
+Make a descriptive git commit:
+
+```bash
+git add .
+git commit -m "Implement [feature name] - verified end-to-end
+
+- Added [specific changes]
+- Tested with browser automation
+- Updated docs/features/feature_list.json: marked test #X as passing
+- Screenshots in verification/ directory
+"
+```
+
+### STEP 9: UPDATE PROGRESS NOTES
+
+Update `.claude/docs/claude-progress.txt` with:
+
+- What you accomplished this session
+- Which test(s) you completed
+- Any issues discovered or fixed
+- What should be worked on next
+- Current completion status (e.g., "45/200 tests passing")
+
+### STEP 10: END SESSION CLEANLY
+
+Before context fills up:
+
+1. Commit all working code
+2. Update .claude/docs/claude-progress.txt
+3. Update docs/features/feature_list.json if tests verified
+4. Ensure no uncommitted changes
+5. Leave app in working state (no broken features)
+
+---
+
+## TESTING REQUIREMENTS
+
+**ALL testing must use browser automation tools.**
+
+Available tools:
+
+- puppeteer_navigate - Start browser and go to URL
+- puppeteer_screenshot - Capture screenshot
+- puppeteer_click - Click elements
+- puppeteer_fill - Fill form inputs
+- puppeteer_evaluate - Execute JavaScript (use sparingly, only for debugging)
+
+Test like a human user with mouse and keyboard. Don't take shortcuts by using JavaScript evaluation.
+Don't use the puppeteer "active tab" tool.
+
+---
+
+## IMPORTANT REMINDERS
+
+**Your Goal:** Production-quality application with all 200+ tests passing
+
+**This Session's Goal:** Complete at least one feature perfectly
+
+**Priority:** Fix broken tests before implementing new features
+
+**Quality Bar:**
+
+- Zero console errors
+- Polished UI matching the design specified in docs/app_spec.txt
+- All features work end-to-end through the UI
+- Fast, responsive, professional
+
+**You have unlimited time.** Take as long as needed to get it right. The most important thing is that you
+leave the code base in a clean state before terminating the session (Step 10).
+
+---
+
+Begin by running Step 1 (Get Your Bearings).

package/templates/base/.claude/commands/explain-code.md

@@ -0,0 +1,194 @@
+# Analyze and Explain Code Functionality
+
+Analyze and explain code functionality
+
+## Instructions
+
+Follow this systematic approach to explain code: **$ARGUMENTS**
+
+1. **Code Context Analysis**
+   - Identify the programming language and framework
+   - Understand the broader context and purpose of the code
+   - Identify the file location and its role in the project
+   - Review related imports, dependencies, and configurations
+
+2. **High-Level Overview**
+   - Provide a summary of what the code does
+   - Explain the main purpose and functionality
+   - Identify the problem the code is solving
+   - Describe how it fits into the larger system
+
+3. **Code Structure Breakdown**
+   - Break down the code into logical sections
+   - Identify classes, functions, and methods
+   - Explain the overall architecture and design patterns
+   - Map out data flow and control flow
+
+4. **Line-by-Line Analysis**
+   - Explain complex or non-obvious lines of code
+   - Describe variable declarations and their purposes
+   - Explain function calls and their parameters
+   - Clarify conditional logic and loops
+
+5. **Algorithm and Logic Explanation**
+   - Describe the algorithm or approach being used
+   - Explain the logic behind complex calculations
+   - Break down nested conditions and loops
+   - Clarify recursive or asynchronous operations
+
+6. **Data Structures and Types**
+   - Explain data types and structures being used
+   - Describe how data is transformed or processed
+   - Explain object relationships and hierarchies
+   - Clarify input and output formats
+
+7. **Framework and Library Usage**
+   - Explain framework-specific patterns and conventions
+   - Describe library functions and their purposes
+   - Explain API calls and their expected responses
+   - Clarify configuration and setup code
+
+8. **Error Handling and Edge Cases**
+   - Explain error handling mechanisms
+   - Describe exception handling and recovery
+   - Identify edge cases being handled
+   - Explain validation and defensive programming
+
+9. **Performance Considerations**
+   - Identify performance-critical sections
+   - Explain optimization techniques being used
+   - Describe complexity and scalability implications
+   - Point out potential bottlenecks or inefficiencies
+
+10. **Security Implications**
+    - Identify security-related code sections
+    - Explain authentication and authorization logic
+    - Describe input validation and sanitization
+    - Point out potential security vulnerabilities
+
+11. **Testing and Debugging**
+    - Explain how the code can be tested
+    - Identify debugging points and logging
+    - Describe mock data or test scenarios
+    - Explain test helpers and utilities
+
+12. **Dependencies and Integrations**
+    - Explain external service integrations
+    - Describe database operations and queries
+    - Explain API interactions and protocols
+    - Clarify third-party library usage
+
+**Explanation Format Examples:**
+
+**For Complex Algorithms:**
+```
+This function implements a depth-first search algorithm:
+
+1. Line 1-3: Initialize a stack with the starting node and a visited set
+2. Line 4-8: Main loop - continue until stack is empty
+3. Line 9-11: Pop a node and check if it's the target
+4. Line 12-15: Add unvisited neighbors to the stack
+5. Line 16: Return null if target not found
+
+Time Complexity: O(V + E) where V is vertices and E is edges
+Space Complexity: O(V) for the visited set and stack
+```
+
+**For API Integration Code:**
+```
+This code handles user authentication with a third-party service:
+
+1. Extract credentials from request headers
+2. Validate credential format and required fields
+3. Make API call to authentication service
+4. Handle response and extract user data
+5. Create session token and set cookies
+6. Return user profile or error response
+
+Error Handling: Catches network errors, invalid credentials, and service unavailability
+Security: Uses HTTPS, validates inputs, and sanitizes responses
+```
+
+**For Database Operations:**
+```
+This function performs a complex database query with joins:
+
+1. Build base query with primary table
+2. Add LEFT JOIN for related user data
+3. Apply WHERE conditions for filtering
+4. Add ORDER BY for consistent sorting
+5. Implement pagination with LIMIT/OFFSET
+6. Execute query and handle potential errors
+7. Transform raw results into domain objects
+
+Performance Notes: Uses indexes on filtered columns, implements connection pooling
+```
+
+13. **Common Patterns and Idioms**
+    - Identify language-specific patterns and idioms
+    - Explain design patterns being implemented
+    - Describe architectural patterns in use
+    - Clarify naming conventions and code style
+
+14. **Potential Improvements**
+    - Suggest code improvements and optimizations
+    - Identify possible refactoring opportunities
+    - Point out maintainability concerns
+    - Recommend best practices and standards
+
+15. **Related Code and Context**
+    - Reference related functions and classes
+    - Explain how this code interacts with other components
+    - Describe the calling context and usage patterns
+    - Point to relevant documentation and resources
+
+16. **Debugging and Troubleshooting**
+    - Explain how to debug issues in this code
+    - Identify common failure points
+    - Describe logging and monitoring approaches
+    - Suggest testing strategies
+
+**Language-Specific Considerations:**
+
+**JavaScript/TypeScript:**
+- Explain async/await and Promise handling
+- Describe closure and scope behavior
+- Clarify this binding and arrow functions
+- Explain event handling and callbacks
+
+**Python:**
+- Explain list comprehensions and generators
+- Describe decorator usage and purpose
+- Clarify context managers and with statements
+- Explain class inheritance and method resolution
+
+**Java:**
+- Explain generics and type parameters
+- Describe annotation usage and processing
+- Clarify stream operations and lambda expressions
+- Explain exception hierarchy and handling
+
+**C#:**
+- Explain LINQ queries and expressions
+- Describe async/await and Task handling
+- Clarify delegate and event usage
+- Explain nullable reference types
+
+**Go:**
+- Explain goroutines and channel usage
+- Describe interface implementation
+- Clarify error handling patterns
+- Explain package structure and imports
+
+**Rust:**
+- Explain ownership and borrowing
+- Describe lifetime annotations
+- Clarify pattern matching and Option/Result types
+- Explain trait implementations
+
+Remember to:
+- Use clear, non-technical language when possible
+- Provide examples and analogies for complex concepts
+- Structure explanations logically from high-level to detailed
+- Include visual diagrams or flowcharts when helpful
+- Tailor the explanation level to the intended audience

package/templates/base/.claude/commands/init-projec.md

@@ -0,0 +1,89 @@
+# YOUR ROLE - INITIALIZER AGENT (Session 1 of Many)
+
+You are the FIRST agent in a long-running autonomous development process.
+Your job is to set up the foundation for all future coding agents.
+
+## FIRST: Read the Project Specification
+
+Start by reading `docs/app_spec.txt` in your working directory. This file contains the complete specification for what you need to build. Read it carefully before proceeding.
+
+## CRITICAL FIRST TASK: Create feature_list.json
+
+Based on `docs/app_spec.txt`, create a file called `docs/features/feature_list.json` with 200 detailed end-to-end test cases. This file is the single source of truth for what needs to be built.
+
+**Format:**
+
+```json
+[
+	{
+		"category": "functional",
+		"description": "Brief description of the feature and what this test verifies",
+		"steps": [
+			"Step 1: Navigate to relevant page",
+			"Step 2: Perform action",
+			"Step 3: Verify expected result"
+		],
+		"passes": false
+	},
+	{
+		"category": "style",
+		"description": "Brief description of UI/UX requirement",
+		"steps": [
+			"Step 1: Navigate to page",
+			"Step 2: Take screenshot",
+			"Step 3: Verify visual requirements"
+		],
+		"passes": false
+	}
+]
+```
+
+**Requirements for feature_list.json:**
+
+- Minimum 200 features total with testing steps for each
+- Both "functional" and "style" categories
+- Mix of narrow tests (2-5 steps) and comprehensive tests (10+ steps)
+- At least 25 tests MUST have 10+ steps each
+- Order features by priority: fundamental features first
+- ALL tests start with "passes": false
+- Cover every feature in the spec exhaustively
+
+**CRITICAL INSTRUCTION:**
+IT IS CATASTROPHIC TO REMOVE OR EDIT FEATURES IN FUTURE SESSIONS.
+Features can ONLY be marked as passing (change "passes": false to "passes": true).
+Never remove features, never edit descriptions, never modify testing steps.
+This ensures no functionality is missed.
+
+### SECOND TASK: Create init.sh
+
+Create a script called `scripts/init.sh` that future agents can use to quickly set up and run the development environment. The script should:
+
+1. Install any required dependencies using pnpm
+2. Start any necessary servers or services
+3. Print helpful information about how to access the running application
+
+Base the script on the technology stack specified in `docs/app_spec.txt`.
+
+### THIRD TASK: Initialize Git
+
+Create a git repository if it doesn't exist and make your first commit with:
+
+- docs/features/feature_list.json (complete with all 200+ features)
+- scripts/init.sh (environment setup script)
+
+Commit message: "CC setup: docs/features/feature_list.json, scripts/init.sh, and project structure"
+
+## ENDING THIS SESSION
+
+Before your context fills up:
+
+1. Commit all work with descriptive messages
+2. Create `.claude/docs/claude-progress.txt` with a summary of what you accomplished
+3. Ensure `docs/features/feature_list.json` is complete and saved
+4. Leave the environment in a clean, working state
+
+The next agent will continue from here with a fresh context window.
+
+---
+
+**Remember:** You have unlimited time across many sessions. Focus on quality over speed. Production-ready is the goal.