metacoding 1.4.2 → 1.5.0

package/templates/assistants/CLAUDE.md

@@ -0,0 +1,156 @@
+# {{PROJECT_NAME}} - Development Guidelines for Claude Code
+
+This file provides project instructions for Claude Code to ensure consistent development practices and workflow adherence.
+
+## Project Overview
+
+{{PROJECT_DESCRIPTION}}
+
+**Project Goals:**
+
+- Provide robust development workflow and best practices
+- Ensure code quality and maintainability standards
+- Enable efficient team collaboration and knowledge sharing
+
+**Tech Stack:** {{TECH_STACK}}
+
+## Development Environment
+
+**Working in:** {{ENVIRONMENT_TYPE}} environment
+**Project Type:** {{PROJECT_DOMAIN}} development
+
+## Core Development Workflow
+
+**CRITICAL: Follow this strict 7-step workflow for ALL development tasks.**
+
+### Step 1: Task Understanding and Planning
+
+- Begin by thoroughly reading project documentation and exploring the codebase
+- Measure your uncertainty level (scale 1.0 to 0.1) before proceeding
+- If uncertainty > 0.1, continue research before asking clarifying questions
+- Present implementation outline and get explicit user confirmation
+- **Documentation-first principle:** No implementation until documentation is complete
+
+### Step 2: Task Management
+
+- Add all tasks to `/_meta/project-task-list.md` BEFORE implementation
+- Use standardized naming: `[AREA]-TASK-[NUMBER]` format
+- Mark tasks "In Progress" with clear descriptions
+- Break complex tasks into smaller, manageable subtasks
+
+### Step 3: Test-Driven Development (TDD)
+
+- Document test cases in `/test/test-documentation.md` FIRST
+- Define expected behavior, inputs, outputs, and edge cases
+- Implement tests after documentation is complete
+- Verify test failure (red phase), then implement code (green phase)
+
+### Step 4: Implementation and Verification
+
+- Write production code to make tests pass
+- Run all tests (new and existing)
+- Get user confirmation that implementation meets requirements
+- Refactor while maintaining test coverage
+
+### Step 5: Documentation and Status Updates
+
+- Update all relevant documentation
+- Mark completed tasks in `/_meta/project-task-list.md`
+- Update test documentation status
+- Update `CHANGELOG.md` with user-facing changes
+
+### Step 6: Version Control
+
+- Commit changes with conventional commit messages
+- Include tests, documentation, and code together
+- Write descriptive commit messages explaining what and why
+- Keep commits atomic (one complete feature per commit)
+
+### Step 7: Workflow Completion Check
+
+- Verify all workflow requirements are satisfied
+- Ensure tests pass, documentation is current, code is committed
+- Complete current workflow before starting new tasks
+
+## Workflow Enforcement Rules
+
+### Documentation-First Principle
+
+**MANDATORY: Document first, execute second for ALL development work.**
+
+- Never begin coding until corresponding documentation is complete
+- Task documentation required in `/_meta/project-task-list.md`
+- Test documentation required in `/test/test-documentation.md`
+- User must explicitly approve plan, scope, and consequences
+
+### Single-Task Focus
+
+**MANDATORY: One change at a time - never mix tasks.**
+
+- Never work on multiple unrelated tasks simultaneously
+- When new requests arise:
+  - **Blocking requests:** Add as subtask to current work
+  - **Non-blocking requests:** Add to task list, complete current workflow first
+- Politely redirect users who try to switch tasks mid-workflow
+
+### Quality Gates
+
+- Complete every step in order - no shortcuts
+- Focus on one task at a time until fully complete
+- TDD approach is mandatory - no skipping tests
+- All documentation must be current
+- No uncommitted changes - commit before moving on
+
+## Project Commands
+
+# Common Commands
+
+- `npm run build`: {{BUILD_COMMAND}}
+- `npm test`: {{TEST_COMMAND}}
+- `npm run lint`: {{LINT_COMMAND}}
+- `npm run typecheck`: {{TYPECHECK_COMMAND}}
+
+# Development Workflow
+
+- Always run tests after making changes
+- Use conventional commit messages (feat:, fix:, docs:, etc.)
+- Prefer running single tests during development for performance
+- Run full test suite before committing
+
+## Code Style Guidelines
+
+- {{CODE_STYLE_GUIDELINES}}
+- Follow language-specific conventions defined in instruction files
+- Use meaningful variable and function names
+- Keep functions focused and reasonably sized
+- Prefer early returns over deep nesting
+- Add comments for complex business logic
+
+## Testing Instructions
+
+- Write tests before implementing features (TDD)
+- Cover edge cases and error conditions
+- Use realistic test data and fixtures
+- Mock external dependencies appropriately
+- Maintain high test coverage for critical functionality
+
+## Repository Structure
+
+```
+{{REPOSITORY_STRUCTURE}}
+```
+
+## Important Notes
+
+- **Temporary files:** Always clean up debug files, temporary outputs, and experimental code
+- **File organization:** Keep source code in appropriate directories, never in project root
+- **Error handling:** Implement comprehensive error handling with proper logging
+- **Performance:** Consider performance implications in all implementations
+- **Security:** Follow secure coding practices, validate inputs, sanitize outputs
+
+## Validation Reminder
+
+After setup, test these instructions by asking:
+**"What is the development workflow for this project?"**
+
+The assistant should reference the 7-step workflow and demonstrate understanding of the documentation-first principle and single-task focus enforcement.

package/templates/assistants/GEMINI.md

@@ -0,0 +1,193 @@
+# {{PROJECT_NAME}} - Style Guide for Gemini Code Assist
+
+This configuration provides development guidelines for Gemini Code Assist to ensure consistent coding practices and workflow adherence.
+
+## Project Configuration
+
+**Project:** {{PROJECT_NAME}}  
+**Description:** {{PROJECT_DESCRIPTION}}
+**Tech Stack:** {{TECH_STACK}}
+**Environment:** {{ENVIRONMENT_TYPE}} development
+**Domain:** {{PROJECT_DOMAIN}}
+
+## Development Workflow Configuration
+
+**IMPORTANT: Follow this mandatory 7-step development workflow for ALL coding tasks.**
+
+### Workflow Step 1: Task Understanding and Planning
+
+**Configuration Rule:** Always analyze before implementing.
+
+- Read project system documentation and explore codebase structure completely
+- Evaluate uncertainty level on scale from 1.0 (total uncertainty) to 0.1 (very low uncertainty)
+- If uncertainty exceeds 0.1, continue research and exploration before requesting clarification
+- Present brief implementation outline with essential details
+- Obtain explicit user confirmation before advancing to next step
+- **Critical Configuration:** No implementation work until all required documentation is complete
+
+### Workflow Step 2: Task Management
+
+**Configuration Rule:** Document tasks before execution.
+
+- Record all tasks in `/_meta/project-task-list.md` BEFORE any implementation work begins
+- Apply standardized naming pattern: `[AREA]-TASK-[NUMBER]`
+- Use area prefixes: CORE, API, UI, DB, AUTH, UTIL, CONFIG, DOC, CLI, TMPL
+- Set task status to "In Progress" with clear descriptions and effort estimates
+- Decompose complex tasks into manageable subtasks with sequential numbering
+
+### Workflow Step 3: Test-Driven Development (TDD)
+
+**Configuration Rule:** Test documentation precedes test implementation.
+
+- Document test cases in `/test/test-documentation.md` BEFORE implementing any test code
+- Define expected behavior including inputs, outputs, and edge case scenarios
+- Create test implementations only after test cases are fully documented
+- Confirm tests fail appropriately (red phase in TDD cycle)
+- Write minimal code to achieve passing tests (green phase in TDD cycle)
+- Clean up test artifacts and organize test data in `/test/fixtures/`
+
+### Workflow Step 4: Implementation and Verification
+
+**Configuration Rule:** Implement with thorough verification.
+
+- Develop production code to satisfy documented requirements
+- Execute all test suites (newly created and existing) to verify functionality
+- Confirm implementation meets user requirements and obtain user validation
+- Refactor code while preserving test coverage (refactor phase in TDD cycle)
+- Remove temporary files and clean up development session artifacts
+
+### Workflow Step 5: Documentation and Status Updates
+
+**Configuration Rule:** Update documentation consistently.
+
+- Update all relevant project documentation files
+- Mark completed tasks in `/_meta/project-task-list.md`
+- Update test execution status in `/test/test-documentation.md`
+- Document user-facing changes in `CHANGELOG.md`
+- Review and update inline code documentation
+
+### Workflow Step 6: Version Control
+
+**Configuration Rule:** Commit changes systematically.
+
+- Apply conventional commit message format (feat:, fix:, docs:, refactor:, test:)
+- Include tests, documentation, and implementation code in atomic commits
+- Compose descriptive commit messages explaining implementation details and rationale
+- Ensure each commit represents complete, functional feature
+
+### Workflow Step 7: Workflow Completion Check
+
+**Configuration Rule:** Verify completion before proceeding.
+
+- Validate all workflow requirements are satisfied
+- Confirm all tests pass and documentation reflects current state
+- Verify code changes are committed with appropriate messages
+- Complete entire workflow cycle before initiating new task planning
+
+## Style Guide Enforcement
+
+### Documentation-First Style Rule
+
+**MANDATORY CONFIGURATION: Documentation precedes execution for ALL development work.**
+
+**Style Enforcement:**
+
+- Prohibit coding, testing, or implementation until corresponding documentation exists
+- Require task documentation in `/_meta/project-task-list.md` before work initiation
+- Require test documentation in `/test/test-documentation.md` before test code creation
+- Require explicit user approval of plan, scope, and consequences before proceeding
+
+**Approved Style Examples:**
+
+- "I'll document this task in the task list, create test case documentation, then obtain your confirmation before implementing"
+- "Let me first document these test cases in test-documentation.md, then proceed with test implementation"
+
+**Style Violations:**
+
+- "I'll implement this feature and update documentation afterward"
+- "I'll create the tests now and document them later"
+
+### Single-Task Style Rule
+
+**MANDATORY CONFIGURATION: One modification at a time - prohibit task mixing.**
+
+**Style Enforcement:**
+
+- Prohibit simultaneous work on multiple unrelated tasks or mixing unrelated modifications
+- When additional requests emerge during active development:
+  - **Blocking requests:** Include as subtask if it prevents current progress
+  - **Non-blocking requests:** Record in task list as separate item, complete current workflow first
+- Redirect users attempting task switching during active workflow
+
+**Style Response Templates:**
+
+- "I've recorded that request in the task list. Completing our current workflow first ensures quality."
+- "That relates to current work, so I'll include it as a subtask to address immediately."
+- "I recognize that as a separate concern. Let me record it in our task list and complete this workflow first."
+
+### Quality Gate Style Rules
+
+**Style Enforcement:**
+
+- No workflow shortcuts: Complete every step sequentially
+- No parallel task execution: Focus on single task until completely finished
+- No test avoidance: Test-Driven Development approach is required
+- No incomplete documentation: All documentation must reflect current state
+- No uncommitted modifications: Commit all work before advancing to new tasks
+
+## Project Style Configuration
+
+### Build and Development Commands
+
+```bash
+# Build configuration
+{{BUILD_COMMAND}}
+
+# Test execution
+{{TEST_COMMAND}}
+
+# Code linting
+{{LINT_COMMAND}}
+
+# Type validation
+{{TYPECHECK_COMMAND}}
+```
+
+### Code Style Standards
+
+- {{CODE_STYLE_GUIDELINES}}
+- Apply conventional commit format consistently (feat:, fix:, docs:, refactor:, test:)
+- Use descriptive variable and function naming conventions
+- Prefer early returns over deeply nested conditional structures
+- Maintain focused, appropriately-sized function implementations
+- Include comments explaining complex business logic implementation
+
+### Testing Style Standards
+
+- Follow Test-Driven Development (TDD) methodology consistently
+- Include edge cases and error condition coverage in test suites
+- Use realistic test data and fixture configurations
+- Apply appropriate mocking strategies for external dependencies in unit tests
+- Maintain high test coverage for critical functionality paths
+
+### Repository Organization Style
+
+```
+{{REPOSITORY_STRUCTURE}}
+```
+
+### Development Style Guidelines
+
+- **File Organization Style:** Prohibit source code placement in project root directory
+- **Temporary File Style:** Clean up debug files, temporary outputs, experimental code artifacts
+- **Error Handling Style:** Implement comprehensive error handling with structured logging
+- **Resource Management Style:** Ensure proper cleanup of resources and event listeners
+- **Performance Style:** Consider performance implications and identify optimization opportunities
+- **Security Style:** Follow secure coding practices, validate inputs, sanitize outputs
+
+## Configuration Validation
+
+After style guide setup, validate configuration by requesting:
+**"What is the development workflow for this project?"**
+
+Expected response should demonstrate understanding of 7-step workflow, emphasize documentation-first style rule, and show comprehension of single-task focus enforcement style.