fYmious/infocom-systems-design
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add hw2

Browse Source
This commit is contained in:
nik
2025-10-03 22:27:28 +03:00
parent 829fad0e17
commit 871cf7e792
16520 changed files with 2967597 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
node_modules/@zenuml/core/docs/ai-context/deployment-infrastructure.md generated vendored Normal file
View File

@@ -0,0 +1,21 @@
# Deployment & Infrastructure Documentation
This document contains deployment and infrastructure-related documentation for the project.
## Purpose
This template serves as a placeholder for documenting:
- Deployment strategies and procedures
- Infrastructure architecture and configuration
- CI/CD pipelines and automation
- Environment management
- Monitoring and observability setup
- Scaling strategies and considerations
## Implementation Note
Replace this template with your actual deployment and infrastructure documentation as your project develops. Focus on patterns and decisions that AI agents need to understand when working with infrastructure-related code or making architectural recommendations.
---
*Customize this template based on your specific deployment and infrastructure requirements.*

89
node_modules/@zenuml/core/docs/ai-context/docs-overview.md generated vendored Normal file
View File

@@ -0,0 +1,89 @@
# Documentation Architecture
This project uses a **3-tier documentation system** that organizes knowledge by stability and scope, enabling efficient AI context loading and scalable development.
## How the 3-Tier System Works
**Tier 1 (Foundation)**: Stable, system-wide documentation that rarely changes - architectural principles, technology decisions, cross-component patterns, and core development protocols.
**Tier 2 (Component)**: Architectural charters for major components - high-level design principles, integration patterns, and component-wide conventions without feature-specific details.
**Tier 3 (Feature-Specific)**: Granular documentation co-located with code - specific implementation patterns, technical details, and local architectural decisions that evolve with features.
This hierarchy allows AI agents to load targeted context efficiently while maintaining a stable foundation of core knowledge.
## Documentation Principles
- **Co-location**: Documentation lives near relevant code
- **Smart Extension**: New documentation files created automatically when warranted
- **AI-First**: Optimized for efficient AI context loading and machine-readable patterns
## Tier 1: Foundational Documentation (System-Wide)
- **[Master Context](/CLAUDE.md)** - *Essential for every session.* Coding standards, security requirements, MCP server integration patterns, and development protocols
- **[Project Structure](/docs/ai-context/project-structure.md)** - *REQUIRED reading.* Complete technology stack, file tree, and system architecture. Must be attached to Gemini consultations
- **[System Integration](/docs/ai-context/system-integration.md)** - *For cross-component work.* Communication patterns, data flow, testing strategies, and performance optimization
- **[Deployment Infrastructure](/docs/ai-context/deployment-infrastructure.md)** - *Infrastructure patterns.* Containerization, monitoring, CI/CD workflows, and scaling strategies
- **[Task Management](/docs/ai-context/handoff.md)** - *Session continuity.* Current tasks, documentation system progress, and next session goals
## Tier 2: Component-Level Documentation
### Backend Components
- **[Backend Context](/backend/CONTEXT.md)** - *Server implementation.* API patterns, database integration, service architecture, and performance considerations
- **[Worker Services](/workers/CONTEXT.md)** - *Background processing.* Job queue patterns, scheduling, and async task management
- **[Shared Libraries](/shared/CONTEXT.md)** - *Reusable code.* Common utilities, shared types, and cross-component functionality
### Frontend Components
- **[Web Application](/frontend/CONTEXT.md)** - *Client implementation.* UI patterns, state management, routing, and user interaction patterns
- **[Mobile Application](/mobile/CONTEXT.md)** - *Mobile implementation.* Platform-specific patterns, native integrations, and mobile optimizations
- **[Admin Dashboard](/admin/CONTEXT.md)** - *Administrative interface.* Permission patterns, admin workflows, and management tools
### Infrastructure Components
- **[Infrastructure Code](/infrastructure/CONTEXT.md)** - *IaC patterns.* Terraform/CloudFormation templates, resource definitions, and deployment automation
- **[Monitoring Setup](/monitoring/CONTEXT.md)** - *Observability patterns.* Metrics collection, alerting rules, and dashboard configurations
## Tier 3: Feature-Specific Documentation
Granular CONTEXT.md files co-located with code for minimal cascade effects:
### Backend Feature Documentation
- **[Core Services](/backend/src/core/services/CONTEXT.md)** - *Business logic patterns.* Service architecture, data processing, integration patterns, and error handling
- **[API Layer](/backend/src/api/CONTEXT.md)** - *API patterns.* Endpoint design, validation, middleware, and request/response handling
- **[Data Layer](/backend/src/data/CONTEXT.md)** - *Data patterns.* Database models, queries, migrations, and data access patterns
- **[Authentication](/backend/src/auth/CONTEXT.md)** - *Auth patterns.* Authentication flows, authorization rules, session management, and security
- **[Integrations](/backend/src/integrations/CONTEXT.md)** - *External services.* Third-party API clients, webhook handlers, and service adapters
### Frontend Feature Documentation
- **[UI Components](/frontend/src/components/CONTEXT.md)** - *Component patterns.* Reusable components, styling patterns, accessibility, and composition strategies
- **[State Management](/frontend/src/store/CONTEXT.md)** - *State patterns.* Global state, local state, data flow, and persistence strategies
- **[API Client](/frontend/src/api/CONTEXT.md)** - *Client patterns.* HTTP clients, error handling, caching, and data synchronization
- **[Routing](/frontend/src/routes/CONTEXT.md)** - *Navigation patterns.* Route definitions, guards, lazy loading, and deep linking
- **[Utilities](/frontend/src/utils/CONTEXT.md)** - *Helper functions.* Formatters, validators, transformers, and common utilities
### Shared Feature Documentation
- **[Common Types](/shared/src/types/CONTEXT.md)** - *Type definitions.* Shared interfaces, enums, and type utilities
- **[Validation Rules](/shared/src/validation/CONTEXT.md)** - *Validation patterns.* Schema definitions, custom validators, and error messages
- **[Constants](/shared/src/constants/CONTEXT.md)** - *Shared constants.* Configuration values, enums, and magic numbers
- **[Utilities](/shared/src/utils/CONTEXT.md)** - *Shared utilities.* Cross-platform helpers, formatters, and common functions
## Adding New Documentation
### New Component
1. Create `/new-component/CONTEXT.md` (Tier 2)
2. Add entry to this file under appropriate section
3. Create feature-specific Tier 3 docs as features develop
### New Feature
1. Create `/component/src/feature/CONTEXT.md` (Tier 3)
2. Reference parent component patterns
3. Add entry to this file under component's features
### Deprecating Documentation
1. Remove obsolete CONTEXT.md files
2. Update this mapping document
3. Check for broken references in other docs
---
*This documentation architecture template should be customized to match your project's actual structure and components. Add or remove sections based on your architecture.*

174
node_modules/@zenuml/core/docs/ai-context/handoff.md generated vendored Normal file
View File

@@ -0,0 +1,174 @@
# Task Management & Handoff Template
This file manages task continuity, session transitions, and knowledge transfer for AI-assisted development sessions.
## Purpose
This template helps maintain:
- **Session continuity** between AI development sessions
- **Task status tracking** for complex, multi-session work
- **Context preservation** when switching between team members
- **Knowledge transfer** for project handoffs
- **Progress documentation** for ongoing development efforts
## Current Session Status
### Active Tasks
Document currently in-progress work:
```markdown
## In Progress
- [ ] Task 1: [Brief description]
- Status: [Started/Blocked/Awaiting review]
- Context: [Relevant files, decisions made]
- Next steps: [What needs to be done next]
- Dependencies: [What this task depends on]
- [ ] Task 2: [Brief description]
- Status: [Current status]
- Files modified: [List of files changed]
- Challenges: [Any issues encountered]
- Notes: [Important context for continuation]
```
### Pending Tasks
Document queued work:
```markdown
## Pending
- [ ] Task A: [Description]
- Priority: [High/Medium/Low]
- Dependencies: [What must be completed first]
- Estimated effort: [Time estimate]
- Context: [Background information]
- [ ] Task B: [Description]
- Priority: [Priority level]
- Requirements: [Specific requirements or constraints]
- Resources needed: [Tools, access, information needed]
```
### Completed Tasks
Track completed work for context:
```markdown
## Completed This Session
- [x] Task X: [Description]
- Completed: [Date]
- Outcome: [What was accomplished]
- Files changed: [Modified files]
- Notes: [Important decisions or lessons learned]
- [x] Task Y: [Description]
- Completed: [Date]
- Impact: [How this affects other tasks]
- Follow-up needed: [Any follow-up actions required]
```
## Architecture & Design Decisions
### Recent Decisions
Document architectural decisions made during development:
```markdown
## Design Decisions Made
- **Decision**: [What was decided]
- Date: [When decision was made]
- Rationale: [Why this approach was chosen]
- Alternatives considered: [Other options evaluated]
- Impact: [How this affects the system]
- Validation: [How to verify this was the right choice]
- **Decision**: [Another decision]
- Context: [Situation that led to this decision]
- Trade-offs: [What was gained/lost with this choice]
- Dependencies: [What this decision depends on]
```
### Technical Debt & Issues
Track technical debt and known issues:
```markdown
## Technical Debt Identified
- **Issue**: [Description of technical debt]
- Location: [Where in codebase]
- Impact: [How it affects development/performance]
- Proposed solution: [How to address it]
- Priority: [When should this be addressed]
- **Issue**: [Another issue]
- Root cause: [Why this debt exists]
- Workaround: [Current mitigation strategy]
- Long-term fix: [Proper solution approach]
```
## Next Session Goals
### Immediate Priorities
Define what should be tackled next:
```markdown
## Next Session Priorities
1. **Primary Goal**: [Main objective for next session]
- Success criteria: [How to know this is complete]
- Prerequisites: [What must be ready beforehand]
- Estimated effort: [Time estimate]
2. **Secondary Goal**: [Secondary objective]
- Dependencies: [What this depends on]
- Resources needed: [Tools, information, access required]
3. **If Time Permits**: [Optional tasks]
- Context: [Background on why these are valuable]
- Preparation: [What needs to be done to start these]
```
### Knowledge Gaps
Document areas needing research or clarification:
```markdown
## Knowledge Gaps to Address
- **Question**: [What needs to be clarified]
- Impact: [How this affects current work]
- Research needed: [What investigation is required]
- Decision maker: [Who can answer this]
- **Unknown**: [Technical uncertainty]
- Options: [Possible approaches to explore]
- Experiments: [What should be tested]
- Timeline: [When this needs to be resolved]
```
## Context for Continuation
### Key Files & Components
Document important files for session continuity:
```markdown
## Files Currently Being Modified
- `[file-path]`: [Purpose and current changes]
- `[file-path]`: [What's being implemented here]
- `[file-path]`: [Status and next steps]
## Important Context Files
- `[context-file]`: [Why this is relevant]
- `[documentation]`: [What information this contains]
- `[reference]`: [How this relates to current work]
```
### Development Environment
Document environment and setup considerations:
```markdown
## Environment Status
- **Development setup**: [Current state of dev environment]
- **Database**: [Schema changes, migrations, data state]
- **External services**: [API keys, service configurations]
- **Testing**: [Test suite status, coverage, failing tests]
- **Build/Deploy**: [Build status, deployment considerations]
```
---
*This template provides a comprehensive framework for managing task continuity and knowledge transfer. Customize it based on your team's workflow, project complexity, and communication needs.*

160
node_modules/@zenuml/core/docs/ai-context/project-structure.md generated vendored Normal file
View File

@@ -0,0 +1,160 @@
# Project Structure Template
This document provides a template for documenting the complete technology stack and file tree structure for your project. **AI agents MUST read this file to understand the project organization before making any changes.**
## Technology Stack Template
### Backend Technologies
Document your backend technology choices:
- **[Language] [Version]** with **[Package Manager]** - Dependency management and packaging
- **[Web Framework] [Version]** - Web framework with specific features (async, type hints, etc.)
- **[Server] [Version]** - Application server configuration
- **[Configuration] [Version]** - Configuration management approach
Example:
```
- Python 3.11+ with Poetry - Dependency management and packaging
- FastAPI 0.115.0+ - Web framework with type hints and async support
- Uvicorn 0.32.0+ - ASGI server with standard extras
- Pydantic Settings 2.5.2+ - Configuration management with type validation
```
### Integration Services & APIs
Document external services and integrations:
- **[Service Name] [API/SDK Version]** - Purpose and usage pattern
- **[AI Service] [Version]** - AI/ML service integration details
- **[Database] [Version]** - Data storage and management
- **[Monitoring] [Version]** - Observability and logging
### Real-time Communication
Document real-time features:
- **[WebSocket Library]** - Real-time communication patterns
- **[HTTP Client]** - Async HTTP communication
- **[Message Queue]** - Event processing (if applicable)
### Development & Quality Tools
Document development toolchain:
- **[Formatter] [Version]** - Code formatting
- **[Linter] [Version]** - Code quality and linting
- **[Type Checker] [Version]** - Static type checking
- **[Testing Framework] [Version]** - Testing approach
- **[Task Runner]** - Build automation and task orchestration
### Frontend Technologies (if applicable)
Document frontend technology stack:
- **[Language] [Version]** - Frontend development language
- **[Framework] [Version]** - UI framework
- **[Build Tool] [Version]** - Development and build tooling
- **[Deployment] [Version]** - Deployment and hosting approach
### Future Technologies
Document planned technology additions:
- **[Planned Technology]** - Future integration plans
- **[Platform]** - Target platform expansion
- **[Service]** - Planned service integrations
## Complete Project Structure Template
```
[PROJECT-NAME]/
├── README.md # Project overview and setup
├── CLAUDE.md # Master AI context file
├── [BUILD-FILE] # Build configuration (Makefile, package.json, etc.)
├── .gitignore # Git ignore patterns
├── .[IDE-CONFIG]/ # IDE workspace configuration
│ ├── settings.[ext] # IDE settings
│ ├── extensions.[ext] # Recommended extensions
│ └── launch.[ext] # Debug configurations
├── [BACKEND-DIR]/ # Backend application
│ ├── CONTEXT.md # Backend-specific AI context
│ ├── src/ # Source code
│ │ ├── config/ # Configuration management
│ │ │ └── settings.[ext] # Application settings
│ │ ├── core/ # Core business logic
│ │ │ ├── CONTEXT.md # Core logic patterns
│ │ │ ├── services/ # Business services
│ │ │ │ ├── [service1].[ext] # Service implementations
│ │ │ │ └── [service2].[ext]
│ │ │ ├── models/ # Data models
│ │ │ │ ├── [model1].[ext] # Model definitions
│ │ │ │ └── [model2].[ext]
│ │ │ └── utils/ # Utility functions
│ │ │ ├── logging.[ext] # Structured logging
│ │ │ ├── validation.[ext] # Input validation
│ │ │ └── helpers.[ext] # Helper functions
│ │ ├── api/ # API layer
│ │ │ ├── CONTEXT.md # API patterns and conventions
│ │ │ ├── routes/ # API route definitions
│ │ │ │ ├── [resource1].[ext] # Resource-specific routes
│ │ │ │ └── [resource2].[ext]
│ │ │ ├── middleware/ # API middleware
│ │ │ │ ├── auth.[ext] # Authentication middleware
│ │ │ │ ├── logging.[ext] # Request logging
│ │ │ │ └── validation.[ext] # Request validation
│ │ │ └── schemas/ # Request/response schemas
│ │ │ ├── [schema1].[ext] # Data schemas
│ │ │ └── [schema2].[ext]
│ │ └── integrations/ # External service integrations
│ │ ├── CONTEXT.md # Integration patterns
│ │ ├── [service1]/ # Service-specific integration
│ │ │ ├── client.[ext] # API client
│ │ │ ├── models.[ext] # Integration models
│ │ │ └── handlers.[ext] # Response handlers
│ │ └── [service2]/
│ ├── tests/ # Test suite
│ │ ├── unit/ # Unit tests
│ │ ├── integration/ # Integration tests
│ │ └── fixtures/ # Test fixtures and data
│ ├── [PACKAGE-FILE] # Package configuration
│ └── [ENV-FILE] # Environment configuration
├── [FRONTEND-DIR]/ # Frontend application (if applicable)
│ ├── CONTEXT.md # Frontend-specific AI context
│ ├── src/ # Source code
│ │ ├── components/ # UI components
│ │ │ ├── CONTEXT.md # Component patterns
│ │ │ ├── common/ # Shared components
│ │ │ └── [feature]/ # Feature-specific components
│ │ ├── pages/ # Page components/routes
│ │ │ ├── [page1].[ext] # Page implementations
│ │ │ └── [page2].[ext]
│ │ ├── stores/ # State management
│ │ │ ├── CONTEXT.md # State management patterns
│ │ │ ├── [store1].[ext] # Store implementations
│ │ │ └── [store2].[ext]
│ │ ├── api/ # API client layer
│ │ │ ├── CONTEXT.md # Client patterns
│ │ │ ├── client.[ext] # HTTP client setup
│ │ │ └── endpoints/ # API endpoint definitions
│ │ ├── utils/ # Utility functions
│ │ │ ├── logging.[ext] # Client-side logging
│ │ │ ├── validation.[ext] # Form validation
│ │ │ └── helpers.[ext] # Helper functions
│ │ └── assets/ # Static assets
│ ├── tests/ # Frontend tests
│ ├── [BUILD-CONFIG] # Build configuration
│ └── [PACKAGE-FILE] # Package configuration
├── docs/ # Documentation
│ ├── ai-context/ # AI-specific documentation
│ │ ├── project-structure.md # This file
│ │ ├── docs-overview.md # Documentation architecture
│ │ ├── system-integration.md # Integration patterns
│ │ ├── deployment-infrastructure.md # Infrastructure docs
│ │ └── handoff.md # Task management
│ ├── api/ # API documentation
│ ├── deployment/ # Deployment guides
│ └── development/ # Development guides
├── scripts/ # Automation scripts
│ ├── setup.[ext] # Environment setup
│ ├── deploy.[ext] # Deployment scripts
│ └── maintenance/ # Maintenance scripts
├── [INFRASTRUCTURE-DIR]/ # Infrastructure as code (if applicable)
│ ├── [PROVIDER]/ # Cloud provider configurations
│ ├── docker/ # Container configurations
│ └── monitoring/ # Monitoring and alerting
└── [CONFIG-FILES] # Root-level configuration files
```
---
*This template provides a comprehensive foundation for documenting project structure. Adapt it based on your specific technology stack, architecture decisions, and organizational requirements.*

21
node_modules/@zenuml/core/docs/ai-context/system-integration.md generated vendored Normal file
View File

@@ -0,0 +1,21 @@
# System Integration Documentation
This document contains cross-component integration patterns and system-wide architectural decisions.
## Purpose
This template serves as a placeholder for documenting:
- Cross-component communication patterns
- Data flow architectures between services
- Integration strategies with external systems
- Performance optimization patterns
- Testing strategies for integrated systems
- Error handling across service boundaries
## Implementation Note
Replace this template with your actual system integration documentation as your project develops. Focus on patterns that AI agents need to understand when working across component boundaries or implementing features that span multiple services.
---
*Customize this template based on your specific integration patterns and architectural requirements.*