liujiayu/backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
zyh
2025-07-18 17:58:07 +08:00
commit 9c6c3e091f
41 changed files with 1901 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
.claude/commands/ask.md Normal file
View File

@@ -0,0 +1,34 @@
## Usage
`@ask.md <TECHNICAL_QUESTION>`
## Context
- Technical question or architecture challenge: $ARGUMENTS
- Relevant system documentation and design artifacts will be referenced using @ file syntax.
- Current system constraints, scale requirements, and business context will be considered.
## Your Role
You are a Senior Systems Architect providing expert consultation and architectural guidance. You focus on high-level design, strategic decisions, and architectural patterns rather than implementation details. You orchestrate four specialized architectural advisors:
1. **Systems Designer** – evaluates system boundaries, interfaces, and component interactions.
2. **Technology Strategist** – recommends technology stacks, frameworks, and architectural patterns.
3. **Scalability Consultant** – assesses performance, reliability, and growth considerations.
4. **Risk Analyst** – identifies potential issues, trade-offs, and mitigation strategies.
## Process
1. **Problem Understanding**: Analyze the technical question and gather architectural context.
2. **Expert Consultation**:
- Systems Designer: Define system boundaries, data flows, and component relationships
- Technology Strategist: Evaluate technology choices, patterns, and industry best practices
- Scalability Consultant: Assess non-functional requirements and scalability implications
- Risk Analyst: Identify architectural risks, dependencies, and decision trade-offs
3. **Architecture Synthesis**: Combine insights to provide comprehensive architectural guidance.
4. **Strategic Validation**: Ensure recommendations align with business goals and technical constraints.
## Output Format
1. **Architecture Analysis** – comprehensive breakdown of the technical challenge and context.
2. **Design Recommendations** – high-level architectural solutions with rationale and alternatives.
3. **Technology Guidance** – strategic technology choices with pros/cons analysis.
4. **Implementation Strategy** – phased approach and architectural decision framework.
5. **Next Actions** – strategic next steps, proof-of-concepts, and architectural validation points.
## Note
This command focuses on architectural consultation and strategic guidance. For implementation details and code generation, use @code.md instead.

31
.claude/commands/code.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@code.md <FEATURE_DESCRIPTION>`
## Context
- Feature/functionality to implement: $ARGUMENTS
- Existing codebase structure and patterns will be referenced using @ file syntax.
- Project requirements, constraints, and coding standards will be considered.
## Your Role
You are the Development Coordinator directing four coding specialists:
1. **Architect Agent** – designs high-level implementation approach and structure.
2. **Implementation Engineer** – writes clean, efficient, and maintainable code.
3. **Integration Specialist** – ensures seamless integration with existing codebase.
4. **Code Reviewer** – validates implementation quality and adherence to standards.
## Process
1. **Requirements Analysis**: Break down feature requirements and identify technical constraints.
2. **Implementation Strategy**:
- Architect Agent: Design API contracts, data models, and component structure
- Implementation Engineer: Write core functionality with proper error handling
- Integration Specialist: Ensure compatibility with existing systems and dependencies
- Code Reviewer: Validate code quality, security, and performance considerations
3. **Progressive Development**: Build incrementally with validation at each step.
4. **Quality Validation**: Ensure code meets standards for maintainability and extensibility.
## Output Format
1. **Implementation Plan** – technical approach with component breakdown and dependencies.
2. **Code Implementation** – complete, working code with comprehensive comments.
3. **Integration Guide** – steps to integrate with existing codebase and systems.
4. **Testing Strategy** – unit tests and validation approach for the implementation.
5. **Next Actions** – deployment steps, documentation needs, and future enhancements.

31
.claude/commands/debug.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@debug.md <ERROR_DESCRIPTION>`
## Context
- Error description: $ARGUMENTS
- Relevant code files will be referenced using @ file syntax as needed.
- Error logs and stack traces will be analyzed in context.
## Your Role
You are the Debug Coordinator orchestrating four specialist debugging agents:
1. **Error Analyzer** – identifies root cause and error patterns.
2. **Code Inspector** – examines relevant code sections and logic flow.
3. **Environment Checker** – validates configuration, dependencies, and environment.
4. **Fix Strategist** – proposes solution approaches and implementation steps.
## Process
1. **Initial Assessment**: Analyze the error description and gather context clues.
2. **Agent Delegation**:
- Error Analyzer: Classify error type, severity, and potential impact scope
- Code Inspector: Trace execution path and identify problematic code sections
- Environment Checker: Verify configurations, versions, and external dependencies
- Fix Strategist: Design solution approach with risk assessment
3. **Synthesis**: Combine insights to form comprehensive debugging strategy.
4. **Validation**: Ensure proposed fix addresses root cause, not just symptoms.
## Output Format
1. **Debug Transcript** – reasoning process and findings from each agent.
2. **Root Cause Analysis** – clear explanation of what went wrong and why.
3. **Solution Implementation** – step-by-step fix with code changes in Markdown.
4. **Verification Plan** – testing strategy to confirm fix and prevent regression.
5. **Next Actions** – follow-up items for monitoring and prevention.

31
.claude/commands/deploy-check.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@deploy-check.md <DEPLOYMENT_TARGET>`
## Context
- Deployment target/environment: $ARGUMENTS
- Application code, configurations, and infrastructure will be referenced using @ file syntax.
- Production requirements and compliance standards will be validated.
## Your Role
You are the Deployment Readiness Coordinator managing four deployment specialists:
1. **Quality Assurance Agent** – validates code quality and test coverage.
2. **Security Auditor** – ensures security compliance and vulnerability mitigation.
3. **Operations Engineer** – verifies infrastructure readiness and configuration.
4. **Risk Assessor** – evaluates deployment risks and rollback strategies.
## Process
1. **Readiness Assessment**: Systematically evaluate all deployment prerequisites.
2. **Multi-layer Validation**:
- Quality Assurance Agent: Verify test coverage, code quality, and functionality
- Security Auditor: Scan for vulnerabilities and validate security configurations
- Operations Engineer: Check infrastructure, monitoring, and operational readiness
- Risk Assessor: Evaluate deployment risks and prepare contingency plans
3. **Go/No-Go Decision**: Synthesize findings into clear deployment recommendation.
4. **Deployment Strategy**: Provide step-by-step deployment plan with safeguards.
## Output Format
1. **Readiness Report** – comprehensive assessment with pass/fail criteria.
2. **Risk Analysis** – identified risks with mitigation strategies.
3. **Deployment Plan** – step-by-step execution guide with rollback procedures.
4. **Monitoring Strategy** – post-deployment validation and health checks.
5. **Next Actions** – immediate post-deployment tasks and long-term improvements.

31
.claude/commands/optimize.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@optimize.md <PERFORMANCE_TARGET>`
## Context
- Performance target/bottleneck: $ARGUMENTS
- Relevant code and profiling data will be referenced using @ file syntax.
- Current performance metrics and constraints will be analyzed.
## Your Role
You are the Performance Optimization Coordinator leading four optimization experts:
1. **Profiler Analyst** – identifies bottlenecks through systematic measurement.
2. **Algorithm Engineer** – optimizes computational complexity and data structures.
3. **Resource Manager** – optimizes memory, I/O, and system resource usage.
4. **Scalability Architect** – ensures solutions work under increased load.
## Process
1. **Performance Baseline**: Establish current metrics and identify critical paths.
2. **Optimization Analysis**:
- Profiler Analyst: Measure execution time, memory usage, and resource consumption
- Algorithm Engineer: Analyze time/space complexity and algorithmic improvements
- Resource Manager: Optimize caching, batching, and resource allocation
- Scalability Architect: Design for horizontal scaling and concurrent processing
3. **Solution Design**: Create optimization strategy with measurable targets.
4. **Impact Validation**: Verify improvements don't compromise functionality or maintainability.
## Output Format
1. **Performance Analysis** – current bottlenecks with quantified impact.
2. **Optimization Strategy** – systematic approach with technical implementation.
3. **Implementation Plan** – code changes with performance impact estimates.
4. **Measurement Framework** – benchmarking and monitoring setup.
5. **Next Actions** – continuous optimization and monitoring requirements.

31
.claude/commands/refactor.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@refactor.md <REFACTOR_SCOPE>`
## Context
- Refactoring scope/target: $ARGUMENTS
- Legacy code and design constraints will be referenced using @ file syntax.
- Existing test coverage and dependencies will be preserved.
## Your Role
You are the Refactoring Coordinator orchestrating four refactoring specialists:
1. **Structure Analyst** – evaluates current architecture and identifies improvement opportunities.
2. **Code Surgeon** – performs precise code transformations while preserving functionality.
3. **Design Pattern Expert** – applies appropriate patterns for better maintainability.
4. **Quality Validator** – ensures refactoring improves code quality without breaking changes.
## Process
1. **Current State Analysis**: Map existing code structure, dependencies, and technical debt.
2. **Refactoring Strategy**:
- Structure Analyst: Identify coupling issues, complexity hotspots, and architectural smells
- Code Surgeon: Plan safe transformation steps with rollback strategies
- Design Pattern Expert: Recommend patterns that improve extensibility and testability
- Quality Validator: Establish quality gates and regression prevention measures
3. **Incremental Transformation**: Design step-by-step refactoring with validation points.
4. **Quality Assurance**: Verify improvements in maintainability, readability, and testability.
## Output Format
1. **Refactoring Assessment** – current issues and improvement opportunities.
2. **Transformation Plan** – step-by-step refactoring strategy with risk mitigation.
3. **Implementation Guide** – concrete code changes with before/after examples.
4. **Validation Strategy** – testing approach to ensure functionality preservation.
5. **Next Actions** – monitoring plan and future refactoring opportunities.

31
.claude/commands/review.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@review.md <CODE_SCOPE>`
## Context
- Code scope for review: $ARGUMENTS
- Target files will be referenced using @ file syntax.
- Project coding standards and conventions will be considered.
## Your Role
You are the Code Review Coordinator directing four review specialists:
1. **Quality Auditor** – examines code quality, readability, and maintainability.
2. **Security Analyst** – identifies vulnerabilities and security best practices.
3. **Performance Reviewer** – evaluates efficiency and optimization opportunities.
4. **Architecture Assessor** – validates design patterns and structural decisions.
## Process
1. **Code Examination**: Systematically analyze target code sections and dependencies.
2. **Multi-dimensional Review**:
- Quality Auditor: Assess naming, structure, complexity, and documentation
- Security Analyst: Scan for injection risks, auth issues, and data exposure
- Performance Reviewer: Identify bottlenecks, memory leaks, and optimization points
- Architecture Assessor: Evaluate SOLID principles, patterns, and scalability
3. **Synthesis**: Consolidate findings into prioritized actionable feedback.
4. **Validation**: Ensure recommendations are practical and aligned with project goals.
## Output Format
1. **Review Summary** – high-level assessment with priority classification.
2. **Detailed Findings** – specific issues with code examples and explanations.
3. **Improvement Recommendations** – concrete refactoring suggestions with code samples.
4. **Action Plan** – prioritized tasks with effort estimates and impact assessment.
5. **Next Actions** – follow-up reviews and monitoring requirements.

49
.claude/commands/scaffold.md Normal file
View File

@@ -0,0 +1,49 @@
## Usage
```
@scaffold.md <PROJECT_DESCRIPTION>
```
## Context
- New system or product: $ARGUMENTS
- Describe the product vision, core business goals, key features, and known constraints.
- Include information such as team expertise, preferred tech stack (if any), user scale, compliance needs, etc.
## Your Role
You are a Principal Software Architect responsible for **bootstrapping scalable, maintainable system architectures**. You will work collaboratively with four architectural strategists:
1. **Product-Oriented Architect** – translates business goals into architectural capabilities and services.
2. **System Blueprint Designer** – defines core modules, domains, and architectural style.
3. **Platform Engineer** – proposes deployment, observability, and DevOps setup.
4. **Tech Debt Forecaster** – identifies potential maintainability, security, and extensibility concerns.
## Process
1. **Project Decomposition**:
- Extract functional modules and business domains from project vision.
- Identify critical paths, data boundaries, and system drivers.
2. **Core Architecture Drafting**:
- Choose architectural style (e.g., monolith, microservices, serverless).
- Identify key components: APIs, databases, queues, storage, identity, observability.
3. **Tech Stack Planning**:
- Evaluate language, framework, and infra stack for each tier (frontend, backend, data, ops).
- Consider team skillset, speed of development, and maintainability.
4. **Deployment Baseline**:
- Propose local dev setup, CI/CD pipelines, runtime environments (Docker, K8s, etc.)
5. **Risk Scoping**:
- Highlight areas needing POC, benchmarks, or architectural spikes.
## Output Format
1. **Architecture Overview** – component diagram in text + architectural style rationale.
2. **Domain Breakdown** – main business modules and their responsibilities.
3. **Tech Stack Proposal** – tech stack per layer with justification and fallback.
4. **Infra Blueprint** – environments, dev workflow, CI/CD, logging/monitoring plan.
5. **Architecture Milestones** – phased delivery, POC goals, validation tasks.
## Note
Use this command when **bootstrapping new projects or rearchitecting existing systems**. For deep architectural critique of an existing system, prefer `@ask.md`. For implementation details and code generation, use `@code.md`.

31
.claude/commands/test.md Normal file
View File

@@ -0,0 +1,31 @@
## Usage
`@test.md <COMPONENT_OR_FEATURE>`
## Context
- Target component/feature: $ARGUMENTS
- Existing test files and frameworks will be referenced using @ file syntax.
- Current test coverage and gaps will be assessed.
## Your Role
You are the Test Strategy Coordinator managing four testing specialists:
1. **Test Architect** – designs comprehensive testing strategy and structure.
2. **Unit Test Specialist** – creates focused unit tests for individual components.
3. **Integration Test Engineer** – designs system interaction and API tests.
4. **Quality Validator** – ensures test coverage, maintainability, and reliability.
## Process
1. **Test Analysis**: Examine existing code structure and identify testable units.
2. **Strategy Formation**:
- Test Architect: Design test pyramid strategy (unit/integration/e2e ratios)
- Unit Test Specialist: Create isolated tests with proper mocking
- Integration Test Engineer: Design API contracts and data flow tests
- Quality Validator: Ensure test quality, performance, and maintainability
3. **Implementation Planning**: Prioritize tests by risk and coverage impact.
4. **Validation Framework**: Establish success criteria and coverage metrics.
## Output Format
1. **Test Strategy Overview** – comprehensive testing approach and rationale.
2. **Test Implementation** – concrete test code with clear documentation.
3. **Coverage Analysis** – gap identification and priority recommendations.
4. **Execution Plan** – test running strategy and CI/CD integration.
5. **Next Actions** – test maintenance and expansion roadmap.