How kushibikimashu/scrum works
Project’s Main Purpose and Type
• The README explains that this repository is a scrum team management application operable via both CLI and web interfaces.
• The project involves managing employees and scrum teams, supporting operations such as initial setup, employee registration, team creation, editing, and developer management.
• It is a full-stack application with a clear separation between the command-line interface (CLI) and a Next.js-based Web interface.
File Structure
• The repository is structured into multiple top-level directories:
• apps/cli: Contains the CLI application with commands for initializing the system and managing employees, teams, and developers.
• apps/web: Contains the Next.js web application that provides a graphical interface.
• packages/core: Contains the fundamental business logic, including definitions related to company, scrum artifacts, teams, and events.
• packages/use-case: Holds the application layer implementing various use cases for employee management, scrum team operations, and query services for both CLI and Web.
• packages/config: Contains configuration files for building, testing, etc.
• The clear names such as “developer”, “employee”, “team” in the CLI section and corresponding use-case and repository layers show a clean domain-driven design.
• Presence of testing directories and configuration files suggests a well-organized codebase with a layered structure (Domain, Application, Infrastructure, and Presentation).
Key Components to Capture
a. Main Components:
• CLI Application (apps/cli): Command-line interface for executing scrum team commands.
• Web Application (apps/web): Next.js web application with pages and components for scrum team operations.
• Core Domain Layer (packages/core): Contains domain entities and common business logic (employee, scrum team, product backlog, sprint backlog, etc.).
• Application/Use-Case Layer (packages/use-case): Orchestrates application-specific operations, including command handling and query services for both CLI and web.
• Adapters/Repositories (within packages/use-case/src/gateway): Handles interaction with external data sources (like JSON repositories using lowdb).
• Configuration and Build Tools (packages/config, turbo.json, etc.): Supporting the build, linting, and testing processes.
• Documentation (docs): Contains additional information, such as data models and user stories.
b. Relationships and Interactions:
• Both interfaces (CLI and Web) rely on the use-case/application layer to invoke business logic.
• The use-case layer interacts with the core domain to perform operations (e.g., employee commands, scrum-team commands).
• The use-case layer communicates with persistence through adapters (JSON repositories using lowdb).
• The CLI and Web adapters translate user commands and web requests into application service calls.
• The core domain emits or processes scrum events and domain-specific logic to maintain consistency.
c. Architectural Patterns and Design Principles:
• Layered Architecture / Hexagonal (Ports and Adapters) architecture: Separate adapters (CLI, Web) from the core business logic.
• Domain-Driven Design (DDD): Distinct domain entities and use cases for scrum management.
• Clear separation of concerns: UI (CLI/Web), Application logic (use-case), Domain core (packages/core), and Persistence (gateways/repositories).
d. Relevant Technologies and Frameworks:
• Node.js with TypeScript.
• Next.js for the web application.
• CLI built with Node.js command modules.
• Lowdb for JSON-based persistence.
• Configuration and testing tools such as ESLint, Prettier, and Jest.
Instructed Elements
• Use clear, descriptive labels for each major component (CLI App, Web App, Use-Case Layer, Core Domain, Repository/Adapter Layer, Configuration/Build Tools).