ai-qakit 1.0.0

package/templates/.claude/workflows/documentation-management.md

@@ -0,0 +1,128 @@
+    # Project Documentation Management
+
+### Roadmap & Changelog Maintenance
+- **Project Roadmap** (`./docs/development-roadmap.md`): Living document tracking project phases, milestones, and progress
+- **Project Changelog** (`./docs/project-changelog.md`): Detailed record of all significant changes, features, and fixes
+- **System Architecture** (`./docs/system-architecture.md`): Detailed record of all significant changes, features, and fixes
+- **Code Standards** (`./docs/code-standards.md`): Detailed record of all significant changes, features, and fixes
+- **Technical Documents** (`./docs/technical-documents.md`): Detailed record of all significant changes, features, and fixes
+
+### Automatic Updates Required
+- **After Feature Implementation**: Update roadmap progress status and changelog entries
+- **After Major Milestones**: Review and adjust roadmap phases, update success metrics
+- **After Bug Fixes**: Document fixes in changelog with severity and impact
+- **After Security Updates**: Record security improvements and version updates
+- **Weekly Reviews**: Update progress percentages and milestone statuses
+
+### Documentation Triggers
+The `project-manager` agent MUST update these documents when:
+- A development phase status changes (e.g., from "In Progress" to "Complete")
+- Major features are implemented or released
+- Significant bugs are resolved or security patches applied
+- Project timeline or scope adjustments are made
+- External dependencies or breaking changes occur
+
+### Update Protocol
+1. **Before Updates**: Always read current roadmap and changelog status
+2. **During Updates**: Maintain version consistency and proper formatting
+3. **After Updates**: Verify links, dates, and cross-references are accurate
+4. **Quality Check**: Ensure updates align with actual implementation progress
+
+### Tasks
+
+### Task Location
+Save tasks in `./.claude/tasks/[TASK-ID]/` directory with timestamp and descriptive name.
+
+**Format:** `./.claude/tasks/[TASK-ID]/`
+
+**Example:** `./.claude/tasks/ABC-123/`
+
+#### File Organization
+
+```
+./.claude/tasks/
+├── ABC-123/
+│   ├── README.md
+│   ├── requirements/
+│   │   ├── functional.md
+│   │   ├── non-functional.md
+│   │   └── ...
+│   ├── research/
+│   │   ├── researcher-XX-report.md
+│   │   └── ...
+│   ├── reports/
+│   │   ├── scout-report.md
+│   │   ├── researcher-report.md
+│   │   └── ...
+│   ├── plan/  
+│   │   ├── plan.md                                # Overview access point
+│   │   ├── phase-01-setup-environment.md          # Setup environment
+│   │   ├── phase-02-implement-database.md         # Database models
+│   │   ├── phase-03-implement-api-endpoints.md    # API endpoints
+│   │   ├── phase-04-implement-ui-components.md    # UI components
+│   │   ├── phase-05-implement-authentication.md   # Auth & authorization
+│   │   ├── phase-06-implement-profile.md          # Profile page
+│   │   └── phase-07-write-tests.md                # Tests
+└── ...
+```
+
+#### File Structure
+
+##### Overview Plan (plan.md)
+- Keep generic and under 80 lines
+- List each phase with status/progress
+- Link to detailed phase files
+- Key dependencies
+
+##### Phase Files (phase-XX-name.md)
+Fully respect the `./docs/development-rules.md` file.
+Each phase file should contain:
+
+**Context Links**
+- Links to related reports, files, documentation
+
+**Overview**
+- Priority
+- Current status
+- Brief description
+
+**Key Insights**
+- Important findings from research
+- Critical considerations
+
+**Requirements**
+- Functional requirements
+- Non-functional requirements
+
+**Architecture**
+- System design
+- Component interactions
+- Data flow
+
+**Related Code Files**
+- List of files to modify
+- List of files to create
+- List of files to delete
+
+**Implementation Steps**
+- Detailed, numbered steps
+- Specific instructions
+
+**Todo List**
+- Checkbox list for tracking
+
+**Success Criteria**
+- Definition of done
+- Validation methods
+
+**Risk Assessment**
+- Potential issues
+- Mitigation strategies
+
+**Security Considerations**
+- Auth/authorization
+- Data protection
+
+**Next Steps**
+- Dependencies
+- Follow-up tasks

package/templates/.claude/workflows/e2e-testing-workflow.md

@@ -0,0 +1,36 @@
+# E2E Testing Workflow
+
+## Overview
+Workflow for end-to-end testing of user flows.
+
+## Workflow Steps
+
+### 1. Identify User Flows
+- Map critical user journeys
+- Prioritize by business value
+- Document flow steps
+- Identify test data needs
+
+### 2. Create Page Objects
+- Design page object structure
+- Implement locators
+- Add action methods
+- Include assertions
+
+### 3. Write E2E Tests
+- Implement test scenarios
+- Use page objects
+- Handle async operations
+- Add proper waits
+
+### 4. Execute Tests
+- Run in CI/CD
+- Test across browsers
+- Capture screenshots/videos
+- Handle failures
+
+### 5. Maintain Tests
+- Fix flaky tests
+- Update for UI changes
+- Optimize execution
+- Review coverage

package/templates/.claude/workflows/orchestration-protocol.md

@@ -0,0 +1,16 @@
+# Orchestration Protocol
+
+#### Sequential Chaining
+Chain subagents when tasks have dependencies or require outputs from previous steps:
+- **Planning → Implementation → Testing → Review**: Use for feature development
+- **Research → Design → Code → Documentation**: Use for new system components
+- Each agent completes fully before the next begins
+- Pass context and outputs between agents in the chain
+
+#### Parallel Execution
+Spawn multiple subagents simultaneously for independent tasks:
+- **Code + Tests + Docs**: When implementing separate, non-conflicting components
+- **Multiple Feature Branches**: Different agents working on isolated features
+- **Cross-platform Development**: iOS and Android specific implementations
+- **Careful Coordination**: Ensure no file conflicts or shared resource contention
+- **Merge Strategy**: Plan integration points before parallel execution begins

package/templates/.claude/workflows/performance-testing-workflow.md

@@ -0,0 +1,42 @@
+# Performance Testing Workflow
+
+## Overview
+Workflow for performance and load testing.
+
+## Workflow Steps
+
+### 1. Define Objectives
+- Set performance goals
+- Define SLAs
+- Identify critical paths
+- Determine load profile
+
+### 2. Design Tests
+- Create test scenarios
+- Define workload model
+- Plan data requirements
+- Set up monitoring
+
+### 3. Implement Scripts
+- Write performance scripts
+- Configure virtual users
+- Set up think times
+- Add assertions
+
+### 4. Execute Tests
+- Run baseline tests
+- Execute load tests
+- Perform stress tests
+- Monitor resources
+
+### 5. Analyze Results
+- Review metrics
+- Identify bottlenecks
+- Compare to baselines
+- Generate reports
+
+### 6. Optimize
+- Recommend improvements
+- Retest after fixes
+- Validate improvements
+- Document findings

package/templates/.claude/workflows/primary-workflow.md

@@ -0,0 +1,45 @@
+# Primary Workflow
+
+**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+**IMPORTANT**: Ensure token efficiency while maintaining high quality.
+
+#### 1. Code Implementation
+- Before you start, delegate to `planner` agent to create a implementation plan with TODO tasks in `./plan` directory.
+- When in planning phase, use multiple `researcher` agents in parallel to conduct research on different relevant technical topics and report back to `planner` agent to create implementation plan.
+- Write clean, readable, and maintainable code
+- Follow established architectural patterns
+- Implement features according to specifications
+- Handle edge cases and error scenarios
+- **DO NOT** create new enhanced files, update to the existing files directly.
+- **[IMPORTANT]** After creating or modifying code file, run compile command/script to check for any compile errors.
+
+#### 2. Testing
+- Delegate to `tester` agent to run tests and analyze the summary report.
+  - Write comprehensive unit tests
+  - Ensure high code coverage
+  - Test error scenarios
+  - Validate performance requirements
+- Tests are critical for ensuring code quality and reliability, **DO NOT** ignore failing tests just to pass the build.
+- **IMPORTANT:** make sure you don't use fake data, mocks, cheats, tricks, temporary solutions, just to pass the build or github actions.
+- **IMPORTANT:** Always fix failing tests follow the recommendations and delegate to `tester` agent to run tests again, only finish your session when all tests pass.
+
+#### 3. Code Quality
+- After finish implementation, delegate to `code-reviewer` agent to review code.
+- Follow coding standards and conventions
+- Write self-documenting code
+- Add meaningful comments for complex logic
+- Optimize for performance and maintainability
+
+#### 4. Integration
+- Always follow the plan given by `planner` agent
+- Ensure seamless integration with existing code
+- Follow API contracts precisely
+- Maintain backward compatibility
+- Document breaking changes
+- Delegate to `docs-manager` agent to update docs in `./docs` directory if any.
+
+#### 5. Debugging
+- When a user report bugs or issues on the server or a CI/CD pipeline, delegate to `debugger` agent to run tests and analyze the summary report.
+- Read the summary report from `debugger` agent and implement the fix.
+- Delegate to `tester` agent to run tests and analyze the summary report.
+- If the `tester` agent reports failed tests, fix them follow the recommendations and repeat from the **Step 2**.

package/templates/.claude/workflows/qa-primary-workflow.md

@@ -0,0 +1,48 @@
+# QA Primary Workflow
+
+## Overview
+The primary workflow for QA activities, guiding test planning, execution, and reporting.
+
+## Workflow Steps
+
+### 1. Requirements Analysis
+- Review requirements/user stories
+- Identify testable requirements
+- Clarify ambiguities with stakeholders
+- Document test scope
+
+### 2. Test Planning
+- Define test strategy
+- Identify test types needed
+- Estimate effort
+- Create test plan
+
+### 3. Test Design
+- Create test cases
+- Design test data
+- Prepare test environment
+- Review test cases
+
+### 4. Test Implementation
+- Write automated tests
+- Set up test infrastructure
+- Configure CI/CD integration
+- Validate test setup
+
+### 5. Test Execution
+- Execute test suites
+- Log results
+- Report defects
+- Track progress
+
+### 6. Reporting
+- Generate test reports
+- Analyze metrics
+- Communicate status
+- Recommend actions
+
+## Quality Gates
+- All critical tests pass
+- Coverage meets threshold
+- No critical bugs open
+- Performance within limits

package/templates/.claude/workflows/qa-rules.md

@@ -0,0 +1,42 @@
+# QA Rules and Standards
+
+## Test Naming
+- Use descriptive names: `should [behavior] when [condition]`
+- Group related tests in describe blocks
+- Use consistent naming across project
+
+## Test Structure
+- Follow Arrange-Act-Assert pattern
+- One logical assertion per test
+- Keep tests independent
+- Clean up after tests
+
+## Test Data
+- Use factories for dynamic data
+- Use fixtures for static data
+- Never use production data
+- Isolate test data
+
+## Assertions
+- Use specific matchers
+- Include meaningful messages
+- Assert on behavior, not implementation
+- Verify both positive and negative cases
+
+## Code Quality
+- No hardcoded values
+- DRY - use helpers and utilities
+- Keep tests readable
+- Document complex scenarios
+
+## CI/CD Integration
+- All tests must pass before merge
+- Coverage must meet threshold
+- No flaky tests allowed
+- Fast feedback loop
+
+## Bug Reporting
+- Include reproduction steps
+- Attach evidence (logs, screenshots)
+- Set appropriate severity
+- Link to related tests

package/templates/.claude/workflows/regression-testing-workflow.md

@@ -0,0 +1,36 @@
+# Regression Testing Workflow
+
+## Overview
+Workflow for efficient regression testing after code changes.
+
+## Workflow Steps
+
+### 1. Analyze Changes
+- Review changed files
+- Identify affected components
+- Map to test coverage
+- Assess risk level
+
+### 2. Select Tests
+- Choose relevant test suites
+- Prioritize by risk
+- Consider time budget
+- Include smoke tests
+
+### 3. Execute Regression
+- Run selected tests
+- Monitor execution
+- Capture failures
+- Retry flaky tests
+
+### 4. Analyze Results
+- Review failures
+- Identify real bugs vs flaky
+- Assess impact
+- Prioritize fixes
+
+### 5. Report Status
+- Generate regression report
+- Communicate to team
+- Recommend release decision
+- Document findings

package/templates/.claude/workflows/test-driven-qa-workflow.md

@@ -0,0 +1,37 @@
+# Test-Driven QA Workflow
+
+## Overview
+QA workflow that starts with tests before implementation.
+
+## Workflow Steps
+
+### 1. Understand Requirements
+- Read user story/requirement
+- Identify acceptance criteria
+- Clarify edge cases
+
+### 2. Write Test Cases First
+- Create test cases from acceptance criteria
+- Define expected behaviors
+- Identify test data needs
+
+### 3. Write Automated Tests
+- Write failing tests first
+- Cover happy path and edge cases
+- Include negative tests
+
+### 4. Validate Implementation
+- Run tests against implementation
+- Verify all tests pass
+- Check coverage
+
+### 5. Refine Tests
+- Add missing scenarios
+- Improve test quality
+- Optimize execution
+
+## Benefits
+- Clear requirements understanding
+- Better test coverage
+- Early defect detection
+- Living documentation

package/templates/.codex/config.toml.template

@@ -0,0 +1,29 @@
+# OpenAI Codex Configuration for QA
+
+[general]
+model = "gpt-4"
+temperature = 0.2
+
+[qa]
+# Test frameworks
+test_framework = "vitest"  # or "jest", "pytest"
+e2e_framework = "playwright"  # or "webdriverio"
+
+# Coverage thresholds
+coverage_statements = 80
+coverage_branches = 75
+coverage_functions = 80
+
+[integrations]
+# Jira integration
+jira_enabled = false
+jira_project_key = ""
+jira_base_url = ""
+
+# Testmo integration
+testmo_enabled = false
+testmo_project_id = ""
+
+[prompts]
+# Custom QA prompts directory
+prompts_dir = ".codex/prompts"

package/templates/.codex/prompts/qa-commands.md

@@ -0,0 +1,32 @@
+# QA Commands for Codex
+
+## /qa-help
+Show available QA commands and their usage.
+
+## /qa-investigate
+Investigate a bug:
+1. Analyze the issue
+2. Find root cause
+3. Suggest fix
+4. Recommend prevention
+
+## /qa-review
+Review test quality:
+- Check test structure
+- Analyze coverage
+- Identify gaps
+- Suggest improvements
+
+## /qa-coverage
+Analyze test coverage:
+- Show coverage metrics
+- Identify uncovered code
+- Prioritize gaps
+- Suggest tests to add
+
+## /qa-report
+Generate test report:
+- Summarize results
+- List failures
+- Show coverage
+- Provide recommendations

package/templates/.codex/prompts/test-generation.md

@@ -0,0 +1,29 @@
+# Test Generation Prompts
+
+## /test-unit
+Generate unit tests for the selected code:
+- Follow Arrange-Act-Assert pattern
+- Cover happy path and edge cases
+- Use descriptive test names
+- Include error scenarios
+
+## /test-api
+Generate API tests for the endpoint:
+- Test all HTTP methods
+- Validate request/response
+- Test authentication
+- Cover error cases
+
+## /test-e2e
+Generate E2E tests for the user flow:
+- Create page objects
+- Write test scenarios
+- Add proper assertions
+- Handle async operations
+
+## /test-data
+Generate test data factories:
+- Use faker for realistic data
+- Create factory functions
+- Support overrides
+- Include edge case data