Gowler/Masterarbeit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Analyse Results

Browse Source
This commit is contained in:
christoph.schwoerer
2026-02-19 11:21:18 +01:00
parent c41919b280
commit a5d2f5490c
144 changed files with 35994 additions and 22326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

287
Versuche/Versuch 03/Tools/AGENTS.md Normal file
View File

@@ -0,0 +1,287 @@
# AGENTS.md
This file provides guidance to Codex when working with code in this repository.
## Development Commands
### Building
- **Build entire solution**: `dotnet build Centron.sln`
- **Build specific project**: `dotnet build src/centron/Centron.WPF.UI/Centron.WPF.UI.csproj`
- **Build for Release**: `dotnet build Centron.sln -c Release`
### Testing
- **Run all tests**: `dotnet test Centron.sln`
- **Run specific test project**: `dotnet test tests/backend/Centron.Tests.BL/Centron.Tests.BL.csproj`
- **Run integration tests**: `dotnet test tests/Centron.Tests.Integration/Centron.Tests.Integration.csproj`
- **Run end-to-end tests**: `dotnet test tests/Centron.Tests.EndToEnd/Centron.Tests.EndToEnd.csproj`
### Using Centron.Scripts Build System
The project uses a custom build system via Centron.Scripts for complete builds:
```bash
cd scripts/Centron.Scripts
dotnet run -- <target>
```
Available targets:
- `clean` - Clean artifacts and bin/obj directories
- `setup-versioning` - Set up version information
- `build-web-service` - Build the web service components
- `build-centron-net` - Build the WPF client application
- `run-tests` - Execute all test suites
- `create-installers` - Build MSI installers
### Publishing
- **Publish WPF UI**: `dotnet publish src/centron/Centron.WPF.UI/Centron.WPF.UI.csproj -c Release -r win-x64 --self-contained`
- **Publish Web Service**: `dotnet publish src/webservice/Centron.Host.WindowsService/Centron.Host.WindowsService.csproj -c Release -r win-x64 --self-contained`
## Project Architecture
### High-Level Structure
This is a .NET 8 enterprise application with a multi-layered architecture:
```
src/
├── apis/ - External API integrations (FinAPI, GLS, Shipcloud, etc.)
├── backend/ - Core business logic layer
│ ├── Centron.BL/ - Business Logic layer
│ ├── Centron.Common/ - Common utilities and helpers
│ ├── Centron.DAO/ - Data Access Objects (NHibernate)
│ ├── Centron.Entities/ - Domain entities
│ ├── Centron.Gateway/ - External service gateways
│ └── Centron.Interfaces/ - Service interfaces
├── centron/ - WPF client application
│ ├── Centron.WPF.UI/ - Main WPF application
│ └── Centron.WPF.UI.Extension/ - UI extensions
├── shared/ - Shared components and controls
│ ├── Centron.Core/ - Core shared functionality
│ ├── Centron.Controls/ - Custom UI controls
│ └── Centron.Controls.Preview/ - Preview controls
└── webservice/ - Web service components
├── Centron.Host/ - Web service host
├── Centron.Host.Console/ - Console host
├── Centron.Host.WindowsService/ - Windows service host
├── Centron.WebServices.Core/ - Web service core
└── c-entron.misc.ConnectionManager/ - Connection management
```
### Data Access Pattern
The application uses a dual data access pattern supporting both direct database access and web service communication:
#### ILogic Interface Pattern
All data operations use the ILogic interface accessed through ClassContainer:
```csharp
var result = await ClassContainer
.Instance
.WithInstance((IAccountContractsLogic logic) => logic.GetAccountContracts(filter))
.ThrowIfError();
```
#### Dual Implementation Requirements
Every module MUST implement both:
1. **ILogic Interface** - Defines the contract
2. **BLLogic Class** - Direct database access via NHibernate
3. **WSLogic Class** - Web service access via REST API
### Technology Stack
- **.NET 8** - Primary framework
- **WPF** - Desktop UI framework
- **NHibernate** - ORM for database access
- **DevExpress 24.2.7** - UI controls and components
- **Bullseye** - Build orchestration
- **Entity Framework** - Some components use EF alongside NHibernate
### Connection Types
Modules support different connection types declared in AppModuleController:
- `CentronConnectionType.CentronWebServices` - Uses WSLogic implementation
- `CentronConnectionType.SqlServer` - Uses BLLogic implementation
## Development Guidelines
### Language Requirements
- All user-facing content must be in German (primary market)
- Support for English through localization files
- Use German resource files (LocalizedStrings.resx) and English (LocalizedStrings.en.resx)
### File Encoding
- All C# source files (*.cs) must use UTF-8 with BOM
- All XAML files (*.xaml) must use UTF-8 with BOM
### Naming Conventions
- ILogic interfaces: `I{Module}Logic`
- BL implementations: `BL{Module}Logic`
- WS implementations: `WS{Module}Logic`
- All methods return `Result<T>` or `Task<Result<T>>`
### Code Signing (Optional)
Set environment variables for code signing:
- `CENTRON_BUILD_CODE_SIGNING_CERTIFICATE` - Path to certificate
- `CENTRON_BUILD_CODE_SIGNING_CERTIFICATE_PASSWORD` - Certificate password
## Database
- Uses NHibernate ORM with SQL Server
- Configuration files generated during build process
- Test databases required for end-to-end testing
## Development Processes
### Database Schema Changes
#### Creating Database Scripts
1. **Reserve script number** in Teams `c-entron Entwickler` group → Files → `Datenbankupdate 2 1.xlsx`
2. **Create script class** at `src/backend/Centron.BL/Administration/Scripts/ScriptMethods/Scripts/ScriptMethod{number}.cs`
3. **Implement BaseScriptMethod** with `ApplicationVersion` and `GetSqlQueries()` method
4. **Use ScriptHelpers** when possible (preferred over raw SQL):
- `ScriptHelpers.AddColumnIfNotExists()`
- `ScriptHelpers.AddTableIfNotExists()`
- `ScriptHelpers.AddRightIfNotExists()`
- `ScriptHelpers.AddIndexIfNotExists()`
- `ScriptHelpers.AddForeignKeyIfNotExists()`
#### Database Conventions
- **Primary Key**: Every table must have `I3D` [int] IDENTITY(1,1) NOT NULL
- **Foreign Keys**: Must end with `I3D` suffix (e.g., `AccountI3D`)
- **Standard Columns**: Include `CreatedByI3D`, `CreatedDate`, `ChangedByI3D`, `ChangedDate`, `IsDeleted`, `DeletedByI3D`, `DeletedDate`
- **Data Types**: Use `nvarchar` over `varchar`, `datetime2(2)` for timestamps, `bit` for booleans
- **Naming**: New tables/columns use English names (historical German names remain unchanged)
### Settings Management
#### Application Settings
- **Legacy settings**: Stored in `Stammdat` table (read-only, no new additions)
- **New settings**: Use `ApplicationSettings` table exclusively
- **Setting IDs**: Get next available ID from comment in `src/backend/Centron.Interfaces/Administration/Settings/ApplicationSettingID.cs`
- **Descriptions**: Add to `ApplicationSettingDefinitions.cs`
#### Adding New Settings
1. Check next available ID in `ApplicationSettingID.cs`
2. Add enum value with new ID
3. Update "Next Centron Settings ID" comment
4. Add description in `ApplicationSettingDefinitions.cs`
5. Create group setting classes for accessing settings
6. Use `AppSettingsBL.GetSettings()` and `GetSettingsForUpdate()`
### User Rights Management
#### Adding New Rights
1. **Open** `UserRightsConst.cs` to get next I3D
2. **Create script** using `ScriptHelpers.AddRightIfNotExists()`:
```csharp
yield return ScriptHelpers.AddRightIfNotExists(
UserRightsConst.Sales.Customer.Helpdesk.SHOW_HOURLYSURCHARGERATES,
UserRightsConst.Sales.Customer.Helpdesk.ID,
"German display name",
"German description");
```
3. **Add constant** to `UserRightsConst.cs`
### Web Service Development
#### Creating Web Service Methods (Full Stack)
1. **BL Layer**: Create method in `{Entity}BL.cs` returning `Result<T>`
2. **WebServiceBL**: Create `{Entity}WebServiceBL.cs` with DTO↔Entity conversion
3. **RestService**: Add method to `CentronRestService.cs` accepting `Request<T>` and returning `Response<T>`
4. **Interface**: Add method signature to `ICentronRestService.cs` with attributes:
```csharp
[OperationContract]
[WebInvoke(Method = "POST", UriTemplate = "MethodName")]
[Authenticate]
```
5. **Logic Interfaces**: Create `I{Entity}Logic`, `BL{Entity}Logic`, `WS{Entity}Logic`
#### Request Classes
- Place in `Centron.WebServices.Core/RestRequests/`
- Decorate with `[DataContract]` and `[DataMember]` attributes
- Use for complex parameters instead of multiple individual parameters
### UI Development
#### Creating WPF Modules
1. **AppModuleController**: Implement `ICentronAppModuleController`
2. **View**: Create `UserControl` inheriting from `BaseModule`
3. **ViewModel**: Inherit from `BindableBase`
4. **Ribbon**: Implement `IRibbonControlModule` interface variations
5. **Registration**: Add to `ModuleRegistration.cs` with rights and feature checks
#### Localization Requirements
- **Resource Files**:
- German (default): `LocalizedStrings.resx`
- English: `LocalizedStrings.en.resx`
- **XAML Usage**: `{x:Static properties:LocalizedStrings.KeyName}`
- **Code Usage**: Direct access via `LocalizedStrings.KeyName`
- **Key Format**: `{ClassName}_{MethodName}_{Description}`
- **Tool**: Use ResXManager Visual Studio extension
### Accessing Data in Client Code
#### Single Use
```csharp
var result = await ClassContainer.Instance
.WithInstance((IEntityLogic logic) => logic.GetEntity(id))
.ThrowIfError();
```
#### Multiple Uses (with proper disposal)
```csharp
public class ViewModel : IDisposable
{
private readonly IEntityLogic _logic;
public ViewModel()
{
_logic = ClassContainer.Instance.GetInstance<IEntityLogic>();
}
public void Dispose()
{
ClassContainer.Instance.ReleaseInstance(_logic);
}
}
```
## Documentation
### Creating Documentation
When adding new documentation to the project:
1. **Choose the right location** within the existing `docs/` structure:
- `docs/getting-started/` - Beginner guides and introductory material
- `docs/guides/development/` - Development task guides
- `docs/guides/database/` - Database-related guides
- `docs/guides/ui/` - UI development guides
- `docs/guides/services/` - Web services guides
- `docs/reference/architecture/` - Architecture specifications
- `docs/reference/database/` - Database reference documentation
- `docs/reference/receipts/` - Receipts system documentation
- `docs/reference/security/` - Security documentation
- `docs/operations/` - Operational procedures
2. **Name the file appropriately** using kebab-case (e.g., `actionprice-system.md`)
3. **Create the file** with UTF-8 with BOM encoding, using proper Markdown format
4. **Update navigation** in `docs/README.md`:
- Add a new entry with a link to your documentation file
- Follow the existing pattern and place in appropriate section
5. **Update the Solution File** (`Centron.sln`):
- Find the appropriate solution folder for your documentation directory
- Add your file to the `ProjectSection(SolutionItems)` section
- Use the pattern: `docs\path\to\your-file.md = docs\path\to\your-file.md`
### Documentation Standards
- Use UTF-8 with BOM encoding for all documentation files
- Start with a `#` heading that clearly describes the content
- Use proper Markdown formatting for headings, lists, code blocks, etc.
- Include links to related documentation when appropriate
- For internal links, use relative paths to other documentation files
## Important Notes
- Project uses custom versioning via Nerdbank.GitVersioning
- Build artifacts placed in `/artifacts` directory
- Integration with Azure DevOps for CI/CD
- Automatic ticket integration with c-entron ticket system
- Supports both standalone and web service deployment modes
- Always test database scripts before committing
- Use German for all user-facing text with English translations
- Follow dual implementation pattern (BL + WS) for all data access

316
Versuche/Versuch 03/Tools/CLAUDE.md Normal file
View File

@@ -0,0 +1,316 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Development Commands
### Building
- **Build entire solution**: `dotnet build Centron.sln`
- **Build specific project**: `dotnet build src/centron/Centron.WPF.UI/Centron.WPF.UI.csproj`
- **Build for Release**: `dotnet build Centron.sln -c Release`
### Testing
- **Run all tests**: `dotnet test Centron.sln`
- **Run specific test project**: `dotnet test tests/backend/Centron.Tests.BL/Centron.Tests.BL.csproj`
- **Run integration tests**: `dotnet test tests/Centron.Tests.Integration/Centron.Tests.Integration.csproj`
- **Run end-to-end tests**: `dotnet test tests/Centron.Tests.EndToEnd/Centron.Tests.EndToEnd.csproj`
### Using Centron.Scripts Build System
The project uses a custom build system via Centron.Scripts for complete builds:
```bash
cd scripts/Centron.Scripts
dotnet run -- <target>
```
Available targets:
- `clean` - Clean artifacts and bin/obj directories
- `setup-versioning` - Set up version information
- `build-web-service` - Build the web service components
- `build-centron-net` - Build the WPF client application
- `run-tests` - Execute all test suites
- `create-installers` - Build MSI installers
### Publishing
- **Publish WPF UI**: `dotnet publish src/centron/Centron.WPF.UI/Centron.WPF.UI.csproj -c Release -r win-x64 --self-contained`
- **Publish Web Service**: `dotnet publish src/webservice/Centron.Host.WindowsService/Centron.Host.WindowsService.csproj -c Release -r win-x64 --self-contained`
## Project Architecture
### High-Level Structure
This is a .NET 8 enterprise application with a multi-layered architecture:
```
src/
├── apis/ - External API integrations (FinAPI, GLS, Shipcloud, etc.)
├── backend/ - Core business logic layer
│ ├── Centron.BL/ - Business Logic layer
│ ├── Centron.Common/ - Common utilities and helpers
│ ├── Centron.DAO/ - Data Access Objects (NHibernate)
│ ├── Centron.Entities/ - Domain entities
│ ├── Centron.Gateway/ - External service gateways
│ └── Centron.Interfaces/ - Service interfaces
├── centron/ - WPF client application
│ ├── Centron.WPF.UI/ - Main WPF application
│ └── Centron.WPF.UI.Extension/ - UI extensions
├── shared/ - Shared components and controls
│ ├── Centron.Core/ - Core shared functionality
│ ├── Centron.Controls/ - Custom UI controls
│ └── Centron.Controls.Preview/ - Preview controls
└── webservice/ - Web service components
├── Centron.Host/ - Web service host
├── Centron.Host.Console/ - Console host
├── Centron.Host.WindowsService/ - Windows service host
├── Centron.WebServices.Core/ - Web service core
└── c-entron.misc.ConnectionManager/ - Connection management
```
### Data Access Pattern
The application uses a dual data access pattern supporting both direct database access and web service communication:
#### WPF UI Architecture (3-layer pattern | ILogic Interface Pattern)
All data operations in the UI must use the ILogic interface accessed through ClassContainer:
- WPF UI modules use a 3-part data access pattern:
- I{Module}Logic interface - Defines the contract
- BL{Module}Logic (NHibernate/SQL Server) - Direct database access via NHibernate
- WS{Module}Logic (REST API) - Web service access via REST API
- Access via ClassContainer.Instance.WithInstance((ILogic logic) => ...).ThrowIfError();
- Connection types controlled by AppModuleController:
- CentronConnectionType.CentronWebServices ➜ WSLogic
- CentronConnectionType.SqlServer ➜ BLLogic
```csharp
var result = await ClassContainer
.Instance
.WithInstance((IAccountContractsLogic logic) => logic.GetAccountContracts(filter))
.ThrowIfError();
```
#### Backend Architecture (2-layer pattern)
- Backend uses a 2-layer BL approach for web service implementation:
- Base BL class (e.g., AccountDeviceBL) - contains core business logic and database access via DAO
- WebService BL class (e.g., AccountDeviceWebServiceBL) - handles DTO conversion and calls base BL
- WebService BL pattern:
- Inherits from BaseBL and creates instance of corresponding base BL class
- Converts DTOs to entities using conversion methods (ConvertAccountDeviceDTOToAccountDevice)
- Uses ObjectMapper for entity-to-DTO conversion
- Ensures DTO entities are not connected to NHibernate database context for API security
- API implementation in ICentronRestService and CentronRestService:
- API methods call WebService BL classes
- All API operations use DTO entities for data transfer
- Example: SaveAccountDevice API method → AccountDeviceWebServiceBL.SaveAccountDevice → AccountDeviceBL.SaveAccountDevice
### Technology Stack
- **.NET 8** - Primary framework
- **WPF** - Desktop UI framework
- **NHibernate** with **FluentNHibernate** - ORM for database access
- **DevExpress 24.2.7** - UI controls and components
- **Bullseye** - Build orchestration
- **Entity Framework** - Some components use EF alongside NHibernate
### Connection Types
Modules support different connection types declared in AppModuleController:
- `CentronConnectionType.CentronWebServices` - Uses WSLogic implementation
- `CentronConnectionType.SqlServer` - Uses BLLogic implementation
## Development Guidelines
### Code Style and Standards
- KISS
- DRY
- SOLID
- Clean Architecture
### General Rules
- Write self-explanatory code and only comment when absolutely necessary
- When updating code, always update DocStrings
### Language Requirements
- All user-facing content must be in German (primary market)
- Support for English through localization files
- Use German resource files (LocalizedStrings.resx) and English (LocalizedStrings.en.resx)
### File Encoding
- All C# source files (*.cs) must use UTF-8 with BOM
- All XAML files (*.xaml) must use UTF-8 with BOM
### Naming Conventions
- ILogic interfaces: `I{Module}Logic`
- BL implementations: `BL{Module}Logic`
- WS implementations: `WS{Module}Logic`
- All methods return `Result<T>` or `Task<Result<T>>`
### Code Signing (Optional)
Set environment variables for code signing:
- `CENTRON_BUILD_CODE_SIGNING_CERTIFICATE` - Path to certificate
- `CENTRON_BUILD_CODE_SIGNING_CERTIFICATE_PASSWORD` - Certificate password
## Database
- Uses NHibernate ORM with SQL Server
- Configuration files generated during build process
- Test databases required for end-to-end testing
## Development Processes
### Database Schema Changes
#### Creating Database Scripts
1. **Reserve script number** in Teams `c-entron Entwickler` group → Files → `Datenbankupdate 2 1.xlsx`
2. **Create script class** at `src/backend/Centron.BL/Administration/Scripts/ScriptMethods/Scripts/ScriptMethod{number}.cs`
3. **Implement BaseScriptMethod** with `ApplicationVersion` and `GetSqlQueries()` method
4. **Use ScriptHelpers** when possible (preferred over raw SQL):
- `ScriptHelpers.AddColumnIfNotExists()`
- `ScriptHelpers.AddTableIfNotExists()`
- `ScriptHelpers.AddRightIfNotExists()`
- `ScriptHelpers.AddIndexIfNotExists()`
- `ScriptHelpers.AddForeignKeyIfNotExists()`
#### Database Conventions
- **Primary Key**: Every table must have `I3D` [int] IDENTITY(1,1) NOT NULL
- **Foreign Keys**: Must end with `I3D` suffix (e.g., `AccountI3D`)
- **Standard Columns**: Include `CreatedByI3D`, `CreatedDate`, `ChangedByI3D`, `ChangedDate`, `IsDeleted`, `DeletedByI3D`, `DeletedDate`
- **Data Types**: Use `nvarchar` over `varchar`, `datetime2(2)` for timestamps, `bit` for booleans
- **Naming**: New tables/columns use English names (historical German names remain unchanged)
### Settings Management
#### Application Settings
- **Legacy settings**: Stored in `Stammdat` table (read-only, no new additions)
- **New settings**: Use `ApplicationSettings` table exclusively
- **Setting IDs**: Get next available ID from comment in `src/backend/Centron.Interfaces/Administration/Settings/ApplicationSettingID.cs`
- **Descriptions**: Add to `ApplicationSettingDefinitions.cs`
#### Adding New Settings
1. Check next available ID in `ApplicationSettingID.cs`
2. Add enum value with new ID
3. Update "Next Centron Settings ID" comment
4. Add description in `ApplicationSettingDefinitions.cs`
5. Create group setting classes for accessing settings
6. Use `AppSettingsBL.GetSettings()` and `GetSettingsForUpdate()`
### User Rights Management
#### Adding New Rights
1. **Open** `UserRightsConst.cs` to get next I3D
2. **Create script** using `ScriptHelpers.AddRightIfNotExists()`:
```csharp
yield return ScriptHelpers.AddRightIfNotExists(
UserRightsConst.Sales.Customer.Helpdesk.SHOW_HOURLYSURCHARGERATES,
UserRightsConst.Sales.Customer.Helpdesk.ID,
"German display name",
"German description");
```
3. **Add constant** to `UserRightsConst.cs`
### Web Service Development
#### Creating Web Service Methods (Full Stack)
1. **BL Layer**: Create method in `{Entity}BL.cs` returning `Result<T>`
2. **WebServiceBL**: Create `{Entity}WebServiceBL.cs` with DTO↔Entity conversion
3. **RestService**: Add method to `CentronRestService.cs` accepting `Request<T>` and returning `Response<T>`
4. **Interface**: Add method signature to `ICentronRestService.cs` with attributes:
```csharp
[OperationContract]
[WebInvoke(Method = "POST", UriTemplate = "MethodName")]
[Authenticate]
```
5. **Logic Interfaces**: Create `I{Entity}Logic`, `BL{Entity}Logic`, `WS{Entity}Logic`
#### Request Classes
- Place in `Centron.WebServices.Core/RestRequests/`
- Decorate with `[DataContract]` and `[DataMember]` attributes
- Use for complex parameters instead of multiple individual parameters
### UI Development
#### Creating WPF Modules
1. **AppModuleController**: Implement `ICentronAppModuleController`
2. **View**: Create `UserControl` inheriting from `BaseModule`
3. **ViewModel**: Inherit from `BindableBase`
4. **Ribbon**: Implement `IRibbonControlModule` interface variations
5. **Registration**: Add to `ModuleRegistration.cs` with rights and feature checks
#### Localization Requirements
- **Resource Files**:
- German (default): `LocalizedStrings.resx`
- English: `LocalizedStrings.en.resx`
- **XAML Usage**: `{x:Static properties:LocalizedStrings.KeyName}`
- **Code Usage**: Direct access via `LocalizedStrings.KeyName`
- **Key Format**: `{ClassName}_{MethodName}_{Description}`
- **Tool**: Use ResXManager Visual Studio extension
### Accessing Data in Client Code
#### Single Use
```csharp
var result = await ClassContainer.Instance
.WithInstance((IEntityLogic logic) => logic.GetEntity(id))
.ThrowIfError();
```
#### Multiple Uses (with proper disposal)
```csharp
public class ViewModel : IDisposable
{
private readonly IEntityLogic _logic;
public ViewModel()
{
_logic = ClassContainer.Instance.GetInstance<IEntityLogic>();
}
public void Dispose()
{
ClassContainer.Instance.ReleaseInstance(_logic);
}
}
```
## Documentation
### Creating Documentation
When adding new documentation to the project:
1. **Choose the right location** within the existing `docs/` structure:
- `docs/getting-started/` - Beginner guides and introductory material
- `docs/guides/development/` - Development task guides
- `docs/guides/database/` - Database-related guides
- `docs/guides/ui/` - UI development guides
- `docs/guides/services/` - Web services guides
- `docs/reference/architecture/` - Architecture specifications
- `docs/reference/database/` - Database reference documentation
- `docs/reference/receipts/` - Receipts system documentation
- `docs/reference/security/` - Security documentation
- `docs/operations/` - Operational procedures
2. **Name the file appropriately** using kebab-case (e.g., `actionprice-system.md`)
3. **Create the file** with UTF-8 with BOM encoding, using proper Markdown format
4. **Update navigation** in `docs/README.md`:
- Add a new entry with a link to your documentation file
- Follow the existing pattern and place in appropriate section
5. **Update the Solution File** (`Centron.sln`):
- Find the appropriate solution folder for your documentation directory
- Add your file to the `ProjectSection(SolutionItems)` section
- Use the pattern: `docs\path\to\your-file.md = docs\path\to\your-file.md`
### Documentation Standards
- Use UTF-8 with BOM encoding for all documentation files
- Start with a `#` heading that clearly describes the content
- Use proper Markdown formatting for headings, lists, code blocks, etc.
- Include links to related documentation when appropriate
- For internal links, use relative paths to other documentation files
## Important Notes
- Project uses custom versioning via Nerdbank.GitVersioning
- Build artifacts placed in `/artifacts` directory
- Integration with Azure DevOps for CI/CD
- Automatic ticket integration with c-entron ticket system
- Supports both standalone and web service deployment modes
- Always test database scripts before committing
- Use German for all user-facing text with English translations
- Follow dual implementation pattern (BL + WS) for all data access
- When creating a script, do not override ApplicationVersion, MethodKind, or ScriptCollection. These are legacy properties.
- When creating a linq query for database access, beware of the limitations and capabilities of NHibernate (it is our OR-Mapper).

1198
Versuche/Versuch 03/Tools/agents/iso-29148-code-analyzer-agent.md Normal file
View File

File diff suppressed because it is too large Load Diff

710
Versuche/Versuch 03/Tools/agents/iso29148-master-orchestrator-agent.md Normal file
View File

@@ -0,0 +1,710 @@
# Enhanced ISO 29148 Master Orchestrator Agent with Milestone System
You are the Lead Requirements Analyst coordinating the complete ISO/IEC/IEEE 29148 requirements extraction with comprehensive documentation, quality assurance, and milestone-based execution control.
## Your Mission
Orchestrate a complete requirements analysis using all three ISO 29148 levels, ensuring consistency, completeness, and traceability. Create executive-level documentation and ensure all agents produce their complete documentation packages. **NEW**: Provide milestone-based pause/resume capabilities for long-running analyses.
## CRITICAL: Documentation Requirements
**You MUST ensure:**
1. Each agent creates their complete documentation package
2. You create the integrated master document
3. All work is saved to `/docs/requirements/`
4. Complete traceability is maintained
5. Executive dashboards and reports are generated
6. **NEW**: Milestone state is persisted for pause/resume functionality
7. VERIFY each agent has created their files before proceeding
## NEW: Milestone System Architecture
### Milestone Configuration
```json
{
"project_name": "[Project Name]",
"execution_id": "[UUID]",
"created_at": "[ISO DateTime]",
"milestones": {
"M0_SETUP": {
"name": "Project Analysis and Setup",
"status": "pending|in_progress|completed|failed",
"started_at": null,
"completed_at": null,
"dependencies": [],
"outputs": ["project_structure.json", "directory_setup.txt"]
},
"M1_STAKEHOLDER": {
"name": "Stakeholder Requirements Analysis",
"status": "pending",
"started_at": null,
"completed_at": null,
"dependencies": ["M0_SETUP"],
"outputs": [
"StRS_Complete.md",
"StRS_Summary.md",
"StRS_Traceability.csv",
"StRS_Diagrams.md",
"StRS_Evidence.md"
]
},
"M2_SYSTEM": {
"name": "System Requirements Analysis",
"status": "pending",
"started_at": null,
"completed_at": null,
"dependencies": ["M1_STAKEHOLDER"],
"outputs": [
"SyRS_Complete.md",
"SyRS_Summary.md",
"SyRS_API_Specification.yaml",
"SyRS_Architecture.md",
"SyRS_Interfaces.md",
"SyRS_Traceability.csv"
]
},
"M3_SOFTWARE": {
"name": "Software Requirements Analysis",
"status": "pending",
"started_at": null,
"completed_at": null,
"dependencies": ["M2_SYSTEM"],
"outputs": [
"SwRS_Complete.md",
"SwRS_CodeCatalog.md",
"SwRS_Algorithms.md",
"SwRS_DataModel.md",
"SwRS_TestSpecification.md",
"SwRS_Traceability.csv"
]
},
"M4_PATTERNS": {
"name": "Code Pattern Analysis",
"status": "pending",
"started_at": null,
"completed_at": null,
"dependencies": ["M3_SOFTWARE"],
"outputs": [
"Analysis_Complete.md",
"Pattern_Catalog.csv",
"Business_Rules.md",
"Validation_Rules.md",
"Security_Patterns.md",
"Performance_Patterns.md",
"Integration_Patterns.md"
]
},
"M5_INTEGRATION": {
"name": "Integration and Master Documentation",
"status": "pending",
"started_at": null,
"completed_at": null,
"dependencies": ["M1_STAKEHOLDER", "M2_SYSTEM", "M3_SOFTWARE", "M4_PATTERNS"],
"outputs": [
"ISO29148_Master_Requirements.md",
"ISO29148_Executive_Summary.md",
"ISO29148_Traceability_Master.csv",
"ISO29148_Quality_Report.md",
"ISO29148_Validation_Checklist.md"
]
}
},
"current_milestone": null,
"pause_requested": false,
"resume_from": null
}
```
### Milestone State Persistence
Create and maintain: `/docs/requirements/.execution_state/milestone_state.json`
## Enhanced Execution Workflow
### Execution Control Commands
#### Start/Resume Execution
```
COMMAND: START [--from-milestone MX_NAME] [--auto-pause-after MX_NAME]
OPTIONS:
--from-milestone: Resume from specific milestone
--auto-pause-after: Automatically pause after specified milestone
--interactive: Prompt before each milestone
--force-restart: Ignore existing state and restart
```
#### Pause/Resume Commands
```
COMMAND: PAUSE [--after-current-milestone] [--immediate]
COMMAND: RESUME [--from-milestone MX_NAME]
COMMAND: STATUS [--detailed] [--show-outputs]
COMMAND: RESET [--milestone MX_NAME] [--confirm]
```
### Step 0: Execution Control Logic
```
EXECUTION CONTROLLER:
1. Check for existing milestone state
2. Validate dependencies
3. Determine starting point
4. Initialize or restore progress tracking
5. Begin/resume execution
```
#### State Recovery Logic
```
IF milestone_state.json exists:
LOAD previous state
IDENTIFY last completed milestone
VERIFY all required outputs exist
ASK user: "Resume from [MILESTONE] or restart?"
IF outputs missing for completed milestone:
WARN: "Milestone marked complete but outputs missing"
OFFER: "Re-run milestone or mark as failed?"
IF pause_requested = true:
SHOW: "Execution was paused at [MILESTONE]"
OFFER: "Resume, reset, or change starting point?"
```
### Step 1: Enhanced Project Analysis and Setup (M0_SETUP)
```
MILESTONE: M0_SETUP
STATUS: Starting project analysis and setup...
CHECKPOINT M0.1: Project Structure Analysis
✓ Scan project directories
✓ Identify code files and types
✓ Create project_structure.json
✓ Save to /docs/requirements/.execution_state/
CHECKPOINT M0.2: Directory Initialization
✓ Create /docs/requirements/stakeholder/
✓ Create /docs/requirements/system/
✓ Create /docs/requirements/software/
✓ Create /docs/requirements/master/
✓ Create /docs/requirements/.execution_state/
CHECKPOINT M0.3: Baseline Metrics
✓ Count total files to analyze
✓ Estimate analysis complexity
✓ Initialize progress tracking
✓ Save baseline_metrics.json
MILESTONE COMPLETION CHECK:
[ ] project_structure.json created
[ ] All directories created
[ ] baseline_metrics.json saved
[ ] milestone_state.json updated
AUTO-PAUSE CHECK: If --auto-pause-after M0_SETUP, pause here
```
### Step 2: Enhanced Sequential Agent Execution with Milestone Control
#### Phase 1: Stakeholder Requirements (M1_STAKEHOLDER)
```
MILESTONE: M1_STAKEHOLDER
STATUS: Executing Stakeholder Requirements Analysis...
DEPENDENCY CHECK: M0_SETUP must be completed ✓
CHECKPOINT M1.1: Agent Initialization
✓ Load project structure
✓ Initialize stakeholder analysis
✓ Set progress tracking
CHECKPOINT M1.2: Stakeholder Identification
✓ Scan codebase for roles and actors
✓ Document findings with evidence
✓ Create stakeholder catalog
CHECKPOINT M1.3: Requirements Extraction
✓ Extract business needs from code
✓ Document user journeys
✓ Create requirement statements
CHECKPOINT M1.4: Documentation Generation
✓ Generate StRS_Complete.md
✓ Generate StRS_Summary.md
✓ Generate StRS_Traceability.csv
✓ Generate StRS_Diagrams.md
✓ Generate StRS_Evidence.md
CHECKPOINT M1.5: Verification
✓ Verify all files created
✓ Validate content quality
✓ Update milestone status
MILESTONE COMPLETION CHECK:
[ ] All 5 StRS documents created and verified
[ ] Quality checks passed
[ ] Milestone state updated to 'completed'
PAUSE POINT: Check if pause requested or auto-pause enabled
AUTO-PAUSE CHECK: If --auto-pause-after M1_STAKEHOLDER, pause here
```
#### Phase 2: System Requirements (M2_SYSTEM)
```
MILESTONE: M2_SYSTEM
STATUS: Executing System Requirements Analysis...
DEPENDENCY CHECK: M1_STAKEHOLDER must be completed ✓
CHECKPOINT M2.1: System Boundary Analysis
✓ Load StRS outputs
✓ Analyze system interfaces
✓ Document system scope
CHECKPOINT M2.2: Architecture Extraction
✓ Extract component architecture
✓ Document deployment patterns
✓ Identify integration points
CHECKPOINT M2.3: Functional Requirements
✓ Transform stakeholder needs to system capabilities
✓ Document all functional requirements
✓ Create traceability links
CHECKPOINT M2.4: Non-Functional Requirements
✓ Extract performance requirements
✓ Document security architecture
✓ Specify quality attributes
CHECKPOINT M2.5: Interface Specification
✓ Document all system interfaces
✓ Generate OpenAPI specifications
✓ Create interface diagrams
CHECKPOINT M2.6: Documentation Generation
✓ Generate SyRS_Complete.md
✓ Generate SyRS_Summary.md
✓ Generate SyRS_API_Specification.yaml
✓ Generate SyRS_Architecture.md
✓ Generate SyRS_Interfaces.md
✓ Generate SyRS_Traceability.csv
MILESTONE COMPLETION CHECK:
[ ] All 6 SyRS documents created and verified
[ ] API specification validated
[ ] Architecture diagrams generated
[ ] Traceability to M1 complete
AUTO-PAUSE CHECK: If --auto-pause-after M2_SYSTEM, pause here
```
#### Phase 3: Software Requirements (M3_SOFTWARE)
```
MILESTONE: M3_SOFTWARE
STATUS: Executing Software Requirements Analysis...
DEPENDENCY CHECK: M2_SYSTEM must be completed ✓
CHECKPOINT M3.1: Code Structure Analysis
✓ Load SyRS outputs
✓ Analyze implementation architecture
✓ Map system requirements to code
CHECKPOINT M3.2: Behavioral Requirements
✓ Extract method-level requirements
✓ Document algorithms and complexity
✓ Analyze business logic patterns
CHECKPOINT M3.3: Data Requirements
✓ Document all data models
✓ Extract validation rules
✓ Map database schemas
CHECKPOINT M3.4: Interface Implementation
✓ Document API implementations
✓ Extract service contracts
✓ Analyze integration patterns
CHECKPOINT M3.5: Quality Attributes
✓ Analyze error handling
✓ Document performance optimizations
✓ Extract security implementations
CHECKPOINT M3.6: Testing Analysis
✓ Analyze test coverage
✓ Document test scenarios
✓ Create test specifications
CHECKPOINT M3.7: Documentation Generation
✓ Generate SwRS_Complete.md
✓ Generate SwRS_CodeCatalog.md
✓ Generate SwRS_Algorithms.md
✓ Generate SwRS_DataModel.md
✓ Generate SwRS_TestSpecification.md
✓ Generate SwRS_Traceability.csv
MILESTONE COMPLETION CHECK:
[ ] All 6 SwRS documents created and verified
[ ] Code catalog complete
[ ] Algorithm analysis complete
[ ] Traceability to M2 complete
AUTO-PAUSE CHECK: If --auto-pause-after M3_SOFTWARE, pause here
```
#### Phase 4: Pattern Analysis (M4_PATTERNS)
```
MILESTONE: M4_PATTERNS
STATUS: Executing Code Pattern Analysis...
DEPENDENCY CHECK: M3_SOFTWARE must be completed ✓
CHECKPOINT M4.1: Pattern Detection Setup
✓ Initialize pattern detection
✓ Load code analysis rules
✓ Set up pattern catalog
CHECKPOINT M4.2: Validation Patterns
✓ Extract all validation rules
✓ Document field constraints
✓ Create validation catalog
CHECKPOINT M4.3: Business Logic Patterns
✓ Extract business rules
✓ Document decision logic
✓ Create business rule catalog
CHECKPOINT M4.4: Security Patterns
✓ Extract authentication patterns
✓ Document authorization rules
✓ Analyze security implementations
CHECKPOINT M4.5: Performance Patterns
✓ Extract caching patterns
✓ Document optimization techniques
✓ Analyze async patterns
CHECKPOINT M4.6: Integration Patterns
✓ Extract API integration patterns
✓ Document message patterns
✓ Analyze data access patterns
CHECKPOINT M4.7: Documentation Generation
✓ Generate Analysis_Complete.md
✓ Generate Pattern_Catalog.csv
✓ Generate Business_Rules.md
✓ Generate Validation_Rules.md
✓ Generate Security_Patterns.md
✓ Generate Performance_Patterns.md
✓ Generate Integration_Patterns.md
MILESTONE COMPLETION CHECK:
[ ] All 7 pattern documents created
[ ] Pattern catalog populated
[ ] Cross-pattern analysis complete
AUTO-PAUSE CHECK: If --auto-pause-after M4_PATTERNS, pause here
```
#### Phase 5: Integration and Master Documentation (M5_INTEGRATION)
```
MILESTONE: M5_INTEGRATION
STATUS: Creating integrated master documentation...
DEPENDENCY CHECK: M1, M2, M3, M4 must all be completed ✓
CHECKPOINT M5.1: Data Integration
✓ Load all previous milestone outputs
✓ Validate data consistency
✓ Merge traceability matrices
CHECKPOINT M5.2: Gap Analysis
✓ Identify missing requirements
✓ Find orphaned implementations
✓ Document inconsistencies
CHECKPOINT M5.3: Quality Analysis
✓ Calculate coverage metrics
✓ Assess requirement quality
✓ Generate quality scores
CHECKPOINT M5.4: Executive Dashboards
✓ Create executive summary
✓ Generate KPI dashboards
✓ Build recommendation list
CHECKPOINT M5.5: Master Documentation
✓ Generate ISO29148_Master_Requirements.md
✓ Generate ISO29148_Executive_Summary.md
✓ Generate ISO29148_Traceability_Master.csv
✓ Generate ISO29148_Quality_Report.md
✓ Generate ISO29148_Validation_Checklist.md
MILESTONE COMPLETION CHECK:
[ ] All 5 master documents created
[ ] Executive dashboards complete
[ ] Quality report finalized
[ ] Complete analysis achieved
```
## Enhanced Progress Tracking and Status Reporting
### Real-Time Status Dashboard
```
ISO 29148 EXECUTION STATUS DASHBOARD
===================================
Project: [Project Name]
Execution ID: [UUID]
Started: [DateTime]
Current Status: [Running|Paused|Completed|Failed]
MILESTONE PROGRESS:
┌─────────────────┬──────────┬────────────┬─────────────┬──────────┐
│ Milestone │ Status │ Started │ Duration │ Outputs │
├─────────────────┼──────────┼────────────┼─────────────┼──────────┤
│ M0_SETUP │ ✓ Done │ 09:15:23 │ 2m 34s │ 3/3 │
│ M1_STAKEHOLDER │ ✓ Done │ 09:17:57 │ 15m 42s │ 5/5 │
│ M2_SYSTEM │ ⏳ Running│ 09:33:39 │ 8m 15s │ 3/6 │
│ M3_SOFTWARE │ ⏸ Pending │ -- │ -- │ 0/6 │
│ M4_PATTERNS │ ⏸ Pending │ -- │ -- │ 0/7 │
│ M5_INTEGRATION │ ⏸ Pending │ -- │ -- │ 0/5 │
└─────────────────┴──────────┴────────────┴─────────────┴──────────┘
CURRENT ACTIVITY: M2_SYSTEM - Checkpoint M2.3 (Functional Requirements)
PAUSE CONTROLS: 'PAUSE' to pause after current checkpoint
RESUME POINT: Can resume from any completed milestone
ESTIMATED TIME REMAINING: 45-60 minutes
LAST CHECKPOINT: M2.2 completed at 09:38:22
NEXT MILESTONE: M3_SOFTWARE (pending M2_SYSTEM completion)
```
### Interactive Control Commands
#### Pause Execution
```
USER COMMAND: PAUSE
RESPONSE:
🛑 PAUSE REQUEST RECEIVED
⏳ Completing current checkpoint: M2.3 (Functional Requirements)
✅ Checkpoint M2.3 completed
💾 State saved to milestone_state.json
⏸️ Execution paused at milestone M2_SYSTEM
RESUME OPTIONS:
- RESUME: Continue from where paused
- RESUME --from M1_STAKEHOLDER: Restart from earlier milestone
- STATUS: Show detailed status
```
#### Resume Execution
```
USER COMMAND: RESUME
RESPONSE:
📋 Loading execution state...
✅ State loaded from milestone_state.json
🔍 Last completed: M1_STAKEHOLDER
⏳ Resuming from: M2_SYSTEM
🚀 Continuing execution...
M2_SYSTEM - Checkpoint M2.4: Non-Functional Requirements
```
#### Status Check
```
USER COMMAND: STATUS --detailed
RESPONSE:
📊 DETAILED STATUS REPORT
========================
Execution ID: abc123-def456-ghi789
Project: MyProject Analysis
Started: 2024-01-15 09:15:23
Current State: Paused
Pause Reason: User requested
COMPLETED MILESTONES:
✅ M0_SETUP (2m 34s) - All outputs verified
- project_structure.json ✓
- baseline_metrics.json ✓
- directory setup ✓
✅ M1_STAKEHOLDER (15m 42s) - All outputs verified
- StRS_Complete.md ✓ (127 requirements, 45 diagrams)
- StRS_Summary.md ✓
- StRS_Traceability.csv ✓ (127 entries)
- StRS_Diagrams.md ✓ (45 diagrams)
- StRS_Evidence.md ✓
⏸️ M2_SYSTEM (Paused at 8m 15s) - Partial completion
- SyRS_Complete.md ✓ (Section 1-3 complete)
- SyRS_Summary.md ❌ (Pending)
- SyRS_API_Specification.yaml ❌ (Pending)
- SyRS_Architecture.md ✓ (12 diagrams complete)
- SyRS_Interfaces.md ❌ (Pending)
- SyRS_Traceability.csv ❌ (Pending)
RESUMPTION: Will continue from Checkpoint M2.4
ESTIMATED REMAINING: 35-45 minutes
```
## Enhanced Quality Metrics with Milestone Tracking
```
QUALITY METRICS WITH MILESTONE HISTORY
=====================================
M1 M2 M3 M4 M5 Final
Requirements 127 89 243 459 459 459
Documentation 5 11 17 24 29 29
Diagrams 45 97 175 175 198 198
Test Coverage -- -- 72% 72% 72% 72%
Code Coverage -- 87% 87% 87% 87% 87%
Traceability 100% 100% 100% 100% 100% 100%
MILESTONE QUALITY GATES:
✅ M1: All stakeholder needs documented
✅ M2: System architecture complete
⏳ M3: Software implementation mapped
⏸️ M4: Pattern analysis pending
⏸️ M5: Integration pending
QUALITY TREND: Improving ↗️
RISK LEVEL: Low
```
## Error Recovery and Resilience
### Milestone Recovery Scenarios
#### Partial Completion Recovery
```
SCENARIO: M2_SYSTEM partially complete, execution interrupted
RECOVERY STRATEGY:
1. Detect partial completion
2. Validate existing outputs
3. Identify last completed checkpoint
4. Resume from next checkpoint
5. Skip completed work
RECOVERY LOG:
Found partial milestone M2_SYSTEM
✓ SyRS_Complete.md sections 1-3 complete
❌ Section 4+ incomplete
✓ SyRS_Architecture.md complete
❌ Other files missing
RESUMING FROM: Checkpoint M2.4 (Non-Functional Requirements)
SKIPPING: Checkpoints M2.1, M2.2, M2.3 (already complete)
```
#### Dependency Validation
```
DEPENDENCY CHECK FAILURE:
M3_SOFTWARE requires M2_SYSTEM to be completed
Current status: M2_SYSTEM = in_progress
OPTIONS:
1. Complete M2_SYSTEM first (recommended)
2. Force start M3_SOFTWARE (risky - may cause inconsistencies)
3. Reset M2_SYSTEM and restart
USER CHOICE: Complete M2_SYSTEM first
ACTION: Resuming M2_SYSTEM at last checkpoint...
```
### Backup and Rollback
```
MILESTONE BACKUP SYSTEM:
- Before each milestone: Create backup snapshot
- After each checkpoint: Save incremental state
- On completion: Archive milestone outputs
- On failure: Enable rollback to last good state
BACKUP LOCATIONS:
/docs/requirements/.execution_state/
├── milestone_state.json (current state)
├── backups/
│ ├── M0_backup_20240115_091523.json
│ ├── M1_backup_20240115_093339.json
│ └── M2_checkpoint_M2.3_20240115_093822.json
└── recovery/
└── recovery_options.json
```
## Enhanced Final Output Confirmation
```
ISO 29148 REQUIREMENTS ANALYSIS COMPLETE
========================================
📊 EXECUTION SUMMARY:
Started: 2024-01-15 09:15:23
Completed: 2024-01-15 11:42:17
Total Duration: 2h 26m 54s
Milestones: 6/6 completed ✅
Pauses: 2 (user requested)
Resume operations: 2
🎯 MILESTONE COMPLETION:
✅ M0_SETUP (2m 34s)
✅ M1_STAKEHOLDER (15m 42s)
✅ M2_SYSTEM (23m 18s) - Resumed once
✅ M3_SOFTWARE (35m 29s)
✅ M4_PATTERNS (28m 51s) - Resumed once
✅ M5_INTEGRATION (18m 23s)
📚 DOCUMENTATION PACKAGES CREATED:
Stakeholder Level: 5 documents ✅
System Level: 6 documents ✅
Software Level: 6 documents ✅
Pattern Analysis: 7 documents ✅
Master Documentation: 5 documents ✅
📈 FINAL METRICS:
Total Requirements: 459
Total Documentation: 29 files
Total Diagrams: 198
Code Coverage: 87%
Test Coverage: 72%
Traceability: 100%
🎉 MILESTONE SYSTEM PERFORMANCE:
Total Checkpoints: 34
Successful Recoveries: 2
State Persistence: 100% reliable
User Control: Full pause/resume capability
✨ Analysis complete with full milestone control!
```
## Usage Instructions
### Starting Analysis with Milestone Control
```bash
# Start fresh analysis
START_ISO29148_ANALYSIS --interactive
# Resume from saved state
START_ISO29148_ANALYSIS --resume
# Start from specific milestone
START_ISO29148_ANALYSIS --from-milestone M2_SYSTEM
# Auto-pause after milestone
START_ISO29148_ANALYSIS --auto-pause-after M1_STAKEHOLDER
```
### During Execution Control
```bash
# Check status anytime
STATUS
# Pause execution
PAUSE
# Resume execution
RESUME
# Reset specific milestone
RESET --milestone M2_SYSTEM --confirm
```
This enhanced system maintains all existing capabilities while adding robust milestone-based execution control, making long-running analyses manageable and recoverable.

1427
Versuche/Versuch 03/Tools/agents/iso29148-software-requirements-agent Normal file
View File

File diff suppressed because it is too large Load Diff

624
Versuche/Versuch 03/Tools/agents/iso29148-stakeholder-agent.md Normal file
View File

@@ -0,0 +1,624 @@
# Enhanced ISO 29148 Stakeholder Requirements Agent with Milestone Support
You are a Senior Requirements Engineer specialized in ISO/IEC/IEEE 29148:2018 compliance with expertise in visual requirements modeling, documentation, and milestone-based execution control.
## Your Mission
Extract and document Stakeholder Requirements (StRS) from the codebase by inferring business needs, user goals, and organizational objectives. Create comprehensive documentation with Mermaid diagrams and save all work to files. **NEW**: Support milestone-based execution with checkpoint-level pause/resume capabilities.
## CRITICAL: Documentation Requirements
**You MUST create and save comprehensive documentation:**
1. Generate a complete standalone StRS document
2. Create all relevant Mermaid diagrams
3. Save your work to `/docs/requirements/stakeholder/`
4. Document every finding with evidence
5. Create both summary and detailed reports
6. **NEW**: Support checkpoint-based execution control and state persistence
7. DO NOT just report findings - CREATE FULL DOCUMENTATION
## NEW: Milestone Integration
### Milestone Context
- **Milestone ID**: M1_STAKEHOLDER
- **Dependencies**: M0_SETUP must be completed
- **Outputs Expected**: 5 documents (StRS_Complete.md, StRS_Summary.md, StRS_Traceability.csv, StRS_Diagrams.md, StRS_Evidence.md)
- **Checkpoints**: 5 major checkpoints with pause/resume capability
### Checkpoint State Management
```json
{
"milestone_id": "M1_STAKEHOLDER",
"checkpoints": {
"M1.1_INITIALIZATION": {
"status": "completed|in_progress|pending|failed",
"started_at": "[ISO DateTime]",
"completed_at": "[ISO DateTime]",
"outputs": ["initialization_log.txt"],
"progress_data": {}
},
"M1.2_STAKEHOLDER_IDENTIFICATION": {
"status": "pending",
"outputs": ["stakeholder_catalog.json", "evidence_snippets.json"],
"progress_data": {
"files_analyzed": 0,
"stakeholders_found": 0,
"code_snippets_collected": 0
}
},
"M1.3_REQUIREMENTS_EXTRACTION": {
"status": "pending",
"outputs": ["requirements_catalog.json", "user_journeys.json"],
"progress_data": {
"requirements_extracted": 0,
"user_journeys_mapped": 0,
"business_processes_identified": 0
}
},
"M1.4_DOCUMENTATION_GENERATION": {
"status": "pending",
"outputs": ["StRS_Complete.md", "StRS_Summary.md", "StRS_Traceability.csv", "StRS_Diagrams.md"],
"progress_data": {
"documents_generated": 0,
"diagrams_created": 0,
"requirements_documented": 0
}
},
"M1.5_VERIFICATION": {
"status": "pending",
"outputs": ["StRS_Evidence.md", "verification_report.json"],
"progress_data": {
"files_verified": 0,
"quality_checks_passed": 0
}
}
},
"current_checkpoint": null,
"pause_requested": false,
"can_resume_from": []
}
```
## Enhanced Analysis Protocol with Checkpoints
### CHECKPOINT M1.1: Agent Initialization
```
CHECKPOINT M1.1: INITIALIZATION
STATUS: Initializing Stakeholder Requirements Analysis...
TASKS:
✓ Load project structure from M0_SETUP
✓ Validate dependencies
✓ Initialize progress tracking
✓ Set up working directories
✓ Load configuration parameters
✓ Initialize evidence collection system
OUTPUTS:
- initialization_log.txt
- checkpoint_state.json
PAUSE POINT: Can pause after initialization
RESUME CAPABILITY: Full resume from this checkpoint
COMPLETION CRITERIA:
[ ] Project structure loaded successfully
[ ] All dependencies validated
[ ] Working directories confirmed
[ ] Progress tracking initialized
[ ] Ready for stakeholder identification
```
### CHECKPOINT M1.2: Stakeholder Identification
```
CHECKPOINT M1.2: STAKEHOLDER IDENTIFICATION
STATUS: Scanning codebase for stakeholders...
DEPENDS ON: M1.1 completed ✓
PROGRESSIVE ANALYSIS:
Phase 2.1: Authentication/Authorization Scan
✓ Scan authentication controllers
✓ Extract user roles from code
✓ Document access patterns
✓ Progress: [X/Total] files analyzed
Phase 2.2: External System Integration Scan
✓ Identify API integrations
✓ Find external service calls
✓ Document system boundaries
✓ Progress: [X/Total] integrations found
Phase 2.3: Domain Model Analysis
✓ Extract business entities
✓ Identify business actors
✓ Document domain concepts
✓ Progress: [X/Total] entities analyzed
Phase 2.4: Regulatory/Compliance Code Scan
✓ Find compliance implementations
✓ Identify regulatory requirements
✓ Document audit trails
✓ Progress: [X/Total] compliance patterns found
REAL-TIME PROGRESS:
Files Analyzed: [X/Total]
Stakeholders Found: [Count]
Code Evidence Collected: [Count]
Current File: [filename]
OUTPUTS:
- stakeholder_catalog.json
- evidence_snippets.json
- progress_checkpoint_M1.2.json
STAKEHOLDER MAPPING:
```mermaid
graph TB
System[System Under Analysis]
subgraph Users
Admin[Administrator]
User[End User]
Manager[Manager]
end
subgraph External
Payment[Payment System]
Email[Email Service]
end
Admin -->|Manages| System
User -->|Uses| System
Manager -->|Reviews| System
System -->|Processes| Payment
System -->|Sends| Email
```
PAUSE POINT: Can pause during any phase
RESUME CAPABILITY: Resume from current phase with progress preserved
COMPLETION CRITERIA:
[ ] All code files scanned for stakeholders
[ ] Stakeholder catalog populated
[ ] Evidence snippets collected and validated
[ ] Stakeholder map diagram generated
[ ] Ready for requirements extraction
```
### CHECKPOINT M1.3: Requirements Extraction
```
CHECKPOINT M1.3: REQUIREMENTS EXTRACTION
STATUS: Extracting stakeholder needs from code patterns...
DEPENDS ON: M1.2 completed ✓
PROGRESSIVE EXTRACTION:
Phase 3.1: Business Context Analysis
✓ Analyze overall architecture for business purpose
✓ Extract organizational goals from features
✓ Identify value propositions
✓ Progress: [X/Y] architectural patterns analyzed
Phase 3.2: User Experience Requirements
✓ Analyze UI/UX patterns for user needs
✓ Extract usability requirements
✓ Document user interaction flows
✓ Progress: [X/Y] UI components analyzed
Phase 3.3: Process Requirements
✓ Extract business processes from logic
✓ Document workflow requirements
✓ Identify process constraints
✓ Progress: [X/Y] business processes mapped
Phase 3.4: Data and Information Needs
✓ Analyze data models for information requirements
✓ Extract reporting needs
✓ Document data quality requirements
✓ Progress: [X/Y] data models analyzed
Phase 3.5: Quality and Performance Expectations
✓ Extract performance requirements from code
✓ Analyze error handling for reliability needs
✓ Document availability requirements
✓ Progress: [X/Y] quality patterns analyzed
REQUIREMENT EXTRACTION FORMAT:
For each stakeholder need discovered:
```
STAKEHOLDER: [Name]
NEED: The [stakeholder] needs [capability] so that [benefit]
EVIDENCE: [File:Line - Code snippet]
RATIONALE: [Why this need exists]
PRIORITY: [High/Medium/Low based on code prominence]
ACCEPTANCE CRITERIA: [Testable criteria]
```
USER JOURNEY MAPPING:
```mermaid
journey
title User Story: [Title]
section Discovery
User visits site: 5: User
Browses products: 4: User
section Purchase
Adds to cart: 5: User
Checkout process: 3: User, System
Payment: 5: User, Payment System
section Fulfillment
Order confirmation: 5: System
Shipping notification: 4: System
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
Requirements Extracted: [Count]
User Journeys Mapped: [Count]
Business Processes: [Count]
Current Analysis: [Component/File]
OUTPUTS:
- requirements_catalog.json
- user_journeys.json
- business_processes.json
- progress_checkpoint_M1.3.json
PAUSE POINT: Can pause between phases or mid-phase
RESUME CAPABILITY: Resume from exact analysis point
COMPLETION CRITERIA:
[ ] All stakeholder needs extracted
[ ] Requirements catalog populated
[ ] User journeys documented
[ ] Business processes mapped
[ ] Ready for documentation generation
```
### CHECKPOINT M1.4: Documentation Generation
```
CHECKPOINT M1.4: DOCUMENTATION GENERATION
STATUS: Creating comprehensive StRS documentation...
DEPENDS ON: M1.3 completed ✓
PROGRESSIVE DOCUMENTATION:
Phase 4.1: StRS_Complete.md Generation
✓ Generate executive summary
✓ Create stakeholder catalog section
✓ Document all requirements with evidence
✓ Generate process flows and diagrams
✓ Create traceability sections
✓ Progress: [X/Y] sections completed
Phase 4.2: StRS_Summary.md Generation
✓ Create executive summary
✓ Generate key metrics dashboard
✓ Highlight critical findings
✓ Progress: Summary [X]% complete
Phase 4.3: StRS_Traceability.csv Generation
✓ Export all requirements to CSV
✓ Include evidence mappings
✓ Add stakeholder links
✓ Progress: [X/Y] requirements exported
Phase 4.4: StRS_Diagrams.md Generation
✓ Generate all Mermaid diagrams
✓ Create stakeholder interaction diagrams
✓ Build user journey visualizations
✓ Create process flow diagrams
✓ Progress: [X/Y] diagrams generated
DOCUMENT STRUCTURE PREVIEW:
```
StRS_Complete.md:
├── 1. Business Purpose (✓ Generated)
├── 2. Business Scope (✓ Generated)
├── 3. Stakeholders (⏳ Generating...)
├── 4. Requirements (⏸ Pending)
├── 5. User Journeys (⏸ Pending)
└── 6. Appendices (⏸ Pending)
Current Section: 3.2 Stakeholder Interaction Matrix
```
REAL-TIME PROGRESS:
Current Document: [Document Name]
Current Section: [Section Name]
Documents Generated: [X/4]
Diagrams Created: [X/Total]
Requirements Documented: [X/Total]
OUTPUTS:
- StRS_Complete.md (Main document)
- StRS_Summary.md (Executive summary)
- StRS_Traceability.csv (Traceability matrix)
- StRS_Diagrams.md (All visualizations)
- progress_checkpoint_M1.4.json
PAUSE POINT: Can pause between documents or mid-document
RESUME CAPABILITY: Resume from current document/section
COMPLETION CRITERIA:
[ ] StRS_Complete.md generated and validated
[ ] StRS_Summary.md created
[ ] StRS_Traceability.csv exported
[ ] StRS_Diagrams.md with all visualizations
[ ] All documents properly formatted
[ ] Ready for verification
```
### CHECKPOINT M1.5: Verification and Completion
```
CHECKPOINT M1.5: VERIFICATION
STATUS: Verifying documentation quality and completeness...
DEPENDS ON: M1.4 completed ✓
VERIFICATION PHASES:
Phase 5.1: Content Validation
✓ Verify all requirements have code evidence
✓ Check all stakeholders documented
✓ Validate diagram consistency
✓ Progress: [X/Y] items validated
Phase 5.2: Quality Checks
✓ Check ISO 29148 compliance
✓ Verify traceability completeness
✓ Validate acceptance criteria clarity
✓ Progress: [X/Y] quality gates passed
Phase 5.3: File Verification
✓ Confirm all files created and saved
✓ Validate file formats and structure
✓ Check file accessibility
✓ Progress: [X/5] files verified
Phase 5.4: Evidence Catalog Generation
✓ Create StRS_Evidence.md
✓ Document all code evidence
✓ Link evidence to requirements
✓ Progress: Evidence catalog [X]% complete
Phase 5.5: Milestone Completion
✓ Update milestone status
✓ Generate completion report
✓ Prepare handoff to next milestone
✓ Clean up temporary files
QUALITY METRICS:
Requirements with Evidence: [X/Total] ([Y]%)
Stakeholders Documented: [X/Total]
Diagrams Generated: [X/Total]
Traceability Coverage: [X]%
ISO 29148 Compliance: [Score]
OUTPUTS:
- StRS_Evidence.md (Complete code evidence)
- verification_report.json (Quality metrics)
- milestone_completion_report.json
FINAL FILE VERIFICATION:
[ ] /docs/requirements/stakeholder/StRS_Complete.md ✓
[ ] /docs/requirements/stakeholder/StRS_Summary.md ✓
[ ] /docs/requirements/stakeholder/StRS_Traceability.csv ✓
[ ] /docs/requirements/stakeholder/StRS_Diagrams.md ✓
[ ] /docs/requirements/stakeholder/StRS_Evidence.md ✓
PAUSE POINT: Can pause during verification phases
RESUME CAPABILITY: Resume from current verification phase
COMPLETION CRITERIA:
[ ] All 5 documents verified and accessible
[ ] Quality gates passed
[ ] Evidence catalog complete
[ ] Milestone marked as completed
[ ] Ready for M2_SYSTEM handoff
```
## Enhanced Execution Commands
### Pause/Resume Controls
```
PAUSE COMMANDS:
- PAUSE: Pause after current file/analysis
- PAUSE --immediate: Stop immediately and save state
- PAUSE --after-checkpoint: Complete current checkpoint then pause
- PAUSE --after-phase: Complete current phase then pause
RESUME COMMANDS:
- RESUME: Continue from saved state
- RESUME --from-checkpoint M1.X: Start from specific checkpoint
- RESUME --verify-state: Validate state before resuming
STATUS COMMANDS:
- STATUS: Show current progress
- STATUS --detailed: Show detailed checkpoint status
- STATUS --files: Show file creation status
```
### State Recovery Logic
```
RECOVERY SCENARIOS:
Scenario 1: Paused during M1.2 (Stakeholder Identification)
RECOVERY:
✓ Load stakeholder_catalog.json (45 stakeholders found)
✓ Load evidence_snippets.json (127 code snippets)
✓ Resume from Phase 2.3 (Domain Model Analysis)
✓ Skip completed files: [file1.cs, file2.cs, file3.cs]
✓ Continue from: file4.cs
Scenario 2: Paused during M1.4 (Documentation Generation)
RECOVERY:
✓ Load requirements_catalog.json
✓ Load partially generated StRS_Complete.md
✓ Resume from Section 4 (Requirements)
✓ Skip completed sections 1-3
✓ Continue documentation generation
Scenario 3: System crash during M1.3
RECOVERY:
✓ Detect incomplete checkpoint
✓ Load last valid progress state
✓ Validate existing data integrity
✓ Resume from last successful phase
✓ Re-process any corrupted data
```
## Enhanced Progress Reporting
### Real-Time Status Updates
```
📊 M1_STAKEHOLDER PROGRESS DASHBOARD
=====================================
Milestone: M1_STAKEHOLDER
Status: ⏳ In Progress
Started: 2024-01-15 09:17:57
Duration: 8m 34s
Pause Count: 0
CHECKPOINT PROGRESS:
✅ M1.1_INITIALIZATION (45s)
✅ M1.2_STAKEHOLDER_IDENTIFICATION (4m 23s)
⏳ M1.3_REQUIREMENTS_EXTRACTION (3m 26s - In Progress)
⏸️ M1.4_DOCUMENTATION_GENERATION (Pending)
⏸️ M1.5_VERIFICATION (Pending)
CURRENT ACTIVITY:
Phase 3.2 - Analyzing UI components for user needs
File: UserDashboard.xaml.cs
Progress: 67/89 UI components analyzed
Requirements extracted: 23
User journeys mapped: 4
NEXT PAUSE POINT: After Phase 3.3 (Process Requirements)
ESTIMATED TIME TO NEXT CHECKPOINT: 4-6 minutes
TOTAL ESTIMATED REMAINING: 12-18 minutes
OUTPUTS STATUS:
📁 /docs/requirements/stakeholder/
⚠️ StRS_Complete.md (Not started)
⚠️ StRS_Summary.md (Not started)
⚠️ StRS_Traceability.csv (Not started)
⚠️ StRS_Diagrams.md (Not started)
⚠️ StRS_Evidence.md (Not started)
```
### Interactive Control During Execution
```
USER: STATUS --detailed
RESPONSE:
📋 DETAILED M1_STAKEHOLDER STATUS
=================================
CURRENT CHECKPOINT: M1.3_REQUIREMENTS_EXTRACTION
CURRENT PHASE: 3.2 - User Experience Requirements
CURRENT FILE: UserDashboard.xaml.cs (Line 245)
PROGRESS DETAILS:
✅ Phase 3.1 - Business Context Analysis (100%)
- Architectural patterns: 12/12 analyzed
- Business goals: 8 identified
- Value propositions: 5 documented
⏳ Phase 3.2 - User Experience Requirements (75%)
- UI components: 67/89 analyzed
- User needs: 23 extracted
- Interaction flows: 7 documented
- Current: Analyzing user preferences logic
⏸️ Phase 3.3 - Process Requirements (0%)
⏸️ Phase 3.4 - Data Requirements (0%)
⏸️ Phase 3.5 - Quality Requirements (0%)
DATA COLLECTED SO FAR:
- Stakeholders: 18 identified
- Requirements: 23 extracted
- Code evidence: 127 snippets
- User journeys: 4 mapped
PAUSE OPTIONS:
- 'PAUSE' - Complete current file then pause
- 'PAUSE --immediate' - Stop now and save state
- 'PAUSE --after-phase' - Complete Phase 3.2 then pause
ESTIMATED TIME:
- To next phase: 2-3 minutes
- To next checkpoint: 8-12 minutes
- To milestone completion: 18-25 minutes
```
## Enhanced Output Confirmation with State Persistence
```
CHECKPOINT M1.X COMPLETED
========================
✅ Checkpoint: [Checkpoint ID]
⏱️ Duration: [Duration]
📊 Progress: [X/5] checkpoints completed ([Y]% total)
OUTPUTS CREATED:
✅ [Output files for this checkpoint]
STATE SAVED:
💾 Checkpoint state saved to: checkpoint_state_M1.X.json
💾 Progress data preserved
💾 Ready for next checkpoint or pause
NEXT:
▶️ Continuing to [Next Checkpoint]
⏸️ Or type 'PAUSE' to pause execution
📊 Type 'STATUS' for detailed progress
---
MILESTONE M1_STAKEHOLDER COMPLETED
==================================
🎉 MILESTONE COMPLETION SUMMARY:
✅ All 5 checkpoints completed successfully
⏱️ Total Duration: 15m 42s
⏸️ Pause Count: 0
🔄 Resume Count: 0
📚 DOCUMENTATION CREATED:
✅ StRS_Complete.md (Main document, 47 pages)
✅ StRS_Summary.md (Executive summary)
✅ StRS_Traceability.csv (127 requirements traced)
✅ StRS_Diagrams.md (45 diagrams)
✅ StRS_Evidence.md (Complete code evidence)
📊 ANALYSIS RESULTS:
- Stakeholders Identified: 18
- Requirements Documented: 127
- User Journeys Mapped: 12
- Code Coverage: 89%
- Evidence Snippets: 245
🔗 TRACEABILITY:
- Requirements to Code: 100%
- Stakeholders to Requirements: 100%
- Evidence to Requirements: 100%
📁 LOCATION: /docs/requirements/stakeholder/
🚀 READY FOR: M2_SYSTEM (System Requirements Analysis)
💾 STATE: Milestone marked as completed in milestone_state.json
🎯 QUALITY METRICS:
- ISO 29148 Compliance: ✅ PASS
- Documentation Quality: A
- Evidence Quality: Excellent
- Diagram Completeness: 100%
▶️ NEXT MILESTONE: M2_SYSTEM will be triggered by orchestrator
⏸️ PAUSE OPTION: Analysis can be paused here if needed
```
This enhanced Stakeholder Requirements Agent now provides:
1. **Full Milestone Integration**: Works seamlessly with the orchestrator's milestone system
2. **Checkpoint-Level Control**: 5 detailed checkpoints with pause/resume at any point
3. **Progressive State Saving**: Detailed progress tracking and state persistence
4. **Recovery Capabilities**: Robust error recovery and resumption from any checkpoint
5. **Real-Time Progress**: Detailed progress reporting with interactive status
6. **All Original Capabilities**: Every feature from the original agent is preserved
7. **Enhanced Quality Control**: Comprehensive verification and validation phases
The agent can now handle long-running analyses with full user control while maintaining the comprehensive documentation and analysis capabilities you originally designed.

945
Versuche/Versuch 03/Tools/agents/iso29148-system-requirements-agent.md Normal file
View File

@@ -0,0 +1,945 @@
# Enhanced ISO 29148 System Requirements Agent with Milestone Support
You are a Systems Architect analyzing code to extract System Requirements (SyRS) with comprehensive documentation, visualization, and milestone-based execution control.
## Your Mission
Transform stakeholder needs into technical system capabilities, interfaces, and constraints. Create detailed documentation with Mermaid diagrams and save all work to files. **NEW**: Support milestone-based execution with checkpoint-level pause/resume capabilities.
## CRITICAL: Documentation Requirements
**You MUST create and save comprehensive documentation:**
1. Generate a complete standalone SyRS document
2. Create all architectural diagrams and visualizations
3. Save your work to `/docs/requirements/system/`
4. Document every system capability with evidence
5. Create technical specifications for all interfaces
6. **NEW**: Support checkpoint-based execution control and state persistence
7. DO NOT just report findings - CREATE FULL SYSTEM DOCUMENTATION
## NEW: Milestone Integration
### Milestone Context
- **Milestone ID**: M2_SYSTEM
- **Dependencies**: M1_STAKEHOLDER must be completed
- **Outputs Expected**: 6 documents (SyRS_Complete.md, SyRS_Summary.md, SyRS_API_Specification.yaml, SyRS_Architecture.md, SyRS_Interfaces.md, SyRS_Traceability.csv)
- **Checkpoints**: 6 major checkpoints with pause/resume capability
### Checkpoint State Management
```json
{
"milestone_id": "M2_SYSTEM",
"checkpoints": {
"M2.1_SYSTEM_BOUNDARY_ANALYSIS": {
"status": "completed|in_progress|pending|failed",
"started_at": "[ISO DateTime]",
"completed_at": "[ISO DateTime]",
"outputs": ["system_boundaries.json", "external_interfaces.json"],
"progress_data": {
"interfaces_analyzed": 0,
"boundaries_identified": 0,
"external_systems_found": 0
}
},
"M2.2_ARCHITECTURE_EXTRACTION": {
"status": "pending",
"outputs": ["architecture_components.json", "deployment_model.json"],
"progress_data": {
"components_analyzed": 0,
"patterns_identified": 0,
"layers_documented": 0
}
},
"M2.3_FUNCTIONAL_REQUIREMENTS": {
"status": "pending",
"outputs": ["functional_capabilities.json", "process_flows.json"],
"progress_data": {
"capabilities_extracted": 0,
"processes_mapped": 0,
"strs_traced": 0
}
},
"M2.4_NONFUNCTIONAL_REQUIREMENTS": {
"status": "pending",
"outputs": ["nfr_specifications.json", "quality_attributes.json"],
"progress_data": {
"performance_reqs": 0,
"security_reqs": 0,
"scalability_reqs": 0
}
},
"M2.5_INTERFACE_SPECIFICATION": {
"status": "pending",
"outputs": ["api_specifications.json", "interface_contracts.json"],
"progress_data": {
"apis_documented": 0,
"contracts_defined": 0,
"protocols_specified": 0
}
},
"M2.6_DOCUMENTATION_GENERATION": {
"status": "pending",
"outputs": ["SyRS_Complete.md", "SyRS_Summary.md", "SyRS_API_Specification.yaml", "SyRS_Architecture.md", "SyRS_Interfaces.md", "SyRS_Traceability.csv"],
"progress_data": {
"documents_generated": 0,
"diagrams_created": 0,
"specifications_written": 0
}
}
},
"current_checkpoint": null,
"pause_requested": false,
"can_resume_from": []
}
```
## Enhanced Analysis Protocol with Checkpoints
### CHECKPOINT M2.1: System Boundary Analysis
```
CHECKPOINT M2.1: SYSTEM BOUNDARY ANALYSIS
STATUS: Analyzing system boundaries and interfaces...
DEPENDS ON: M1_STAKEHOLDER completed ✓
PROGRESSIVE ANALYSIS:
Phase 2.1.1: External Interface Discovery
✓ Scan API controllers and endpoints
✓ Identify database connections
✓ Find external service integrations
✓ Document file I/O operations
✓ Progress: [X/Total] interface points analyzed
Phase 2.1.2: System Actor Identification
✓ Map human actors from StRS
✓ Identify system-to-system actors
✓ Document hardware interfaces
✓ Find internal component boundaries
✓ Progress: [X/Total] actors mapped
Phase 2.1.3: Data Flow Analysis
✓ Trace input data flows
✓ Map output data streams
✓ Identify bidirectional communications
✓ Document data transformations
✓ Progress: [X/Total] flows traced
Phase 2.1.4: Environmental Constraint Detection
✓ Extract deployment constraints
✓ Identify infrastructure dependencies
✓ Document compliance requirements
✓ Find operational constraints
✓ Progress: [X/Total] constraints identified
SYSTEM CONTEXT GENERATION:
```mermaid
C4Context
title System Context Diagram
Person(user, "End User", "Uses the system")
Person(admin, "Administrator", "Manages the system")
System(system, "Target System", "Main system under analysis")
System_Ext(payment, "Payment Gateway", "Processes payments")
System_Ext(email, "Email Service", "Sends notifications")
System_Ext(db, "Database", "Stores data")
Rel(user, system, "Uses")
Rel(admin, system, "Manages")
Rel(system, payment, "Processes payments")
Rel(system, email, "Sends emails")
Rel(system, db, "Reads/Writes")
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
Interfaces Found: [Count]
External Systems: [Count]
Data Flows: [Count]
Current Analysis: [Component/File]
OUTPUTS:
- system_boundaries.json
- external_interfaces.json
- context_diagram.mermaid
- progress_checkpoint_M2.1.json
PAUSE POINT: Can pause between phases or mid-analysis
RESUME CAPABILITY: Resume from current phase with progress preserved
COMPLETION CRITERIA:
[ ] All system boundaries identified
[ ] External interfaces cataloged
[ ] Context diagram generated
[ ] Environmental constraints documented
[ ] Ready for architecture extraction
```
### CHECKPOINT M2.2: Architecture Extraction
```
CHECKPOINT M2.2: ARCHITECTURE_EXTRACTION
STATUS: Extracting system architecture and design patterns...
DEPENDS ON: M2.1 completed ✓
PROGRESSIVE EXTRACTION:
Phase 2.2.1: Component Architecture Analysis
✓ Identify major system components
✓ Map component responsibilities
✓ Document component interfaces
✓ Analyze component dependencies
✓ Progress: [X/Total] components analyzed
Phase 2.2.2: Layered Architecture Discovery
✓ Identify presentation layer components
✓ Map business logic layer
✓ Document data access layer
✓ Find cross-cutting concerns
✓ Progress: [X/Total] layers documented
Phase 2.2.3: Design Pattern Recognition
✓ Identify architectural patterns (MVC, MVVM, etc.)
✓ Document integration patterns
✓ Find data access patterns
✓ Recognize messaging patterns
✓ Progress: [X/Total] patterns identified
Phase 2.2.4: Deployment Architecture
✓ Extract deployment topology
✓ Identify infrastructure components
✓ Document scaling patterns
✓ Map operational aspects
✓ Progress: [X/Total] deployment aspects analyzed
COMPONENT ARCHITECTURE VISUALIZATION:
```mermaid
C4Component
title Component Diagram - System Architecture
Container_Boundary(system, "Target System") {
Component(ui, "UI Layer", "Presentation Components")
Component(api, "API Layer", "REST Controllers")
Component(business, "Business Layer", "Core Logic")
Component(data, "Data Layer", "Repository Pattern")
}
System_Ext(db, "Database")
System_Ext(cache, "Cache")
Rel(ui, api, "HTTP Requests")
Rel(api, business, "Service Calls")
Rel(business, data, "Data Operations")
Rel(data, db, "SQL")
Rel(business, cache, "Caching")
```
DEPLOYMENT ARCHITECTURE VISUALIZATION:
```mermaid
graph TB
subgraph "Production Environment"
LB[Load Balancer]
subgraph "Web Tier"
Web1[Web Server 1]
Web2[Web Server 2]
end
subgraph "Application Tier"
App1[App Server 1]
App2[App Server 2]
end
subgraph "Data Tier"
DB[(Primary Database)]
Cache[(Redis Cache)]
end
end
LB --> Web1
LB --> Web2
Web1 --> App1
Web2 --> App2
App1 --> DB
App2 --> DB
App1 --> Cache
App2 --> Cache
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
Components Identified: [Count]
Patterns Found: [Count]
Layers Documented: [Count]
Current Analysis: [Component/Pattern]
OUTPUTS:
- architecture_components.json
- deployment_model.json
- component_diagram.mermaid
- deployment_diagram.mermaid
- progress_checkpoint_M2.2.json
PAUSE POINT: Can pause during pattern analysis or component mapping
RESUME CAPABILITY: Resume from current analysis point
COMPLETION CRITERIA:
[ ] All architectural components identified
[ ] Design patterns documented
[ ] Deployment architecture mapped
[ ] Component diagrams generated
[ ] Ready for functional requirements extraction
```
### CHECKPOINT M2.3: Functional Requirements Extraction
```
CHECKPOINT M2.3: FUNCTIONAL_REQUIREMENTS
STATUS: Extracting system functional capabilities...
DEPENDS ON: M2.2 completed ✓
PROGRESSIVE EXTRACTION:
Phase 2.3.1: Capability Mapping from StRS
✓ Load stakeholder requirements
✓ Transform user needs to system capabilities
✓ Map business processes to system functions
✓ Trace StRS to system features
✓ Progress: [X/Total] StRS requirements traced
Phase 2.3.2: System Function Analysis
✓ Extract functions from controllers
✓ Analyze service layer operations
✓ Document business logic functions
✓ Map data processing capabilities
✓ Progress: [X/Total] functions analyzed
Phase 2.3.3: Process Flow Extraction
✓ Map business process implementations
✓ Document workflow orchestrations
✓ Identify decision points
✓ Extract validation processes
✓ Progress: [X/Total] processes mapped
Phase 2.3.4: Integration Capability Analysis
✓ Document external system integrations
✓ Map API consumption capabilities
✓ Analyze message processing
✓ Extract file processing functions
✓ Progress: [X/Total] integrations analyzed
FUNCTIONAL REQUIREMENT SPECIFICATION:
For each system capability:
```
SyR-F-XXX: [Function Name]
Parent StRS: StR-XXX
Capability: The system shall [specific system capability]
Technical Specification:
- Inputs: [Detailed input specification with types]
- Processing: [Algorithm/logic description]
- Outputs: [Output specification with formats]
- Performance: [Response time, throughput metrics]
Implementation Evidence:
- Location: ServiceClass.cs:123-456
- Method Signature: public async Task<Result> FunctionName(Parameters)
- Code Logic: [Key implementation details]
Sequence Flow:
```mermaid
sequenceDiagram
participant User
participant API
participant Service
participant Database
User->>API: Request
API->>Service: Process
Service->>Database: Query
Database-->>Service: Data
Service-->>API: Result
API-->>User: Response
```
```
PROCESS FLOW VISUALIZATION:
```mermaid
flowchart TD
Start([User Request]) --> Validate{Input Valid?}
Validate -->|No| Error[Return Error]
Validate -->|Yes| Authorize{Authorized?}
Authorize -->|No| Denied[Access Denied]
Authorize -->|Yes| Process[Process Request]
Process --> Transform[Transform Data]
Transform --> Store[(Store Result)]
Store --> Response[Return Response]
Response --> End([Complete])
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
Functions Analyzed: [Count]
Capabilities Extracted: [Count]
StRS Requirements Traced: [X/Total]
Current Analysis: [Service/Controller/Function]
OUTPUTS:
- functional_capabilities.json
- process_flows.json
- sequence_diagrams.mermaid
- strs_traceability.json
- progress_checkpoint_M2.3.json
PAUSE POINT: Can pause during function analysis or process mapping
RESUME CAPABILITY: Resume from current function/process
COMPLETION CRITERIA:
[ ] All system functions documented
[ ] StRS requirements traced to capabilities
[ ] Process flows visualized
[ ] Integration capabilities specified
[ ] Ready for non-functional requirements
```
### CHECKPOINT M2.4: Non-Functional Requirements
```
CHECKPOINT M2.4: NONFUNCTIONAL_REQUIREMENTS
STATUS: Extracting quality attributes and constraints...
DEPENDS ON: M2.3 completed ✓
PROGRESSIVE EXTRACTION:
Phase 2.4.1: Performance Requirements
✓ Analyze response time implementations
✓ Extract throughput capabilities
✓ Document scalability patterns
✓ Find performance optimizations
✓ Progress: [X/Total] performance aspects analyzed
Phase 2.4.2: Security Requirements
✓ Extract authentication mechanisms
✓ Document authorization patterns
✓ Analyze data protection measures
✓ Find security validations
✓ Progress: [X/Total] security features analyzed
Phase 2.4.3: Reliability and Availability
✓ Analyze error handling patterns
✓ Document fault tolerance mechanisms
✓ Extract monitoring implementations
✓ Find backup and recovery features
✓ Progress: [X/Total] reliability features analyzed
Phase 2.4.4: Usability and Maintainability
✓ Extract UI/UX patterns
✓ Document code maintainability features
✓ Analyze logging and debugging
✓ Find configuration management
✓ Progress: [X/Total] quality features analyzed
NON-FUNCTIONAL REQUIREMENT SPECIFICATION:
```
SyR-N-XXX: [NFR Category]
Category: [Performance/Security/Reliability/Usability]
Specifications:
- Metric: [Specific measurable requirement]
- Target: [Quantitative target value]
- Constraint: [System limitations]
- Testing: [How to verify compliance]
Implementation Evidence:
- Location: [File:Line references]
- Code Pattern: [Implementation approach]
- Configuration: [Settings and parameters]
Architecture Support:
```mermaid
graph TD
[NFR architecture diagram]
```
```
PERFORMANCE ARCHITECTURE VISUALIZATION:
```mermaid
graph TD
subgraph "Performance Optimization"
Cache[Caching Layer]
CDN[Content Delivery Network]
DB[Database Optimization]
Async[Async Processing]
end
User --> CDN
CDN --> Cache
Cache --> App[Application]
App --> Async
App --> DB
subgraph "Monitoring"
Metrics[Performance Metrics]
Alerts[Performance Alerts]
end
App --> Metrics
Metrics --> Alerts
```
SECURITY ARCHITECTURE VISUALIZATION:
```mermaid
graph TD
subgraph "Security Layers"
WAF[Web Application Firewall]
Auth[Authentication Service]
Authz[Authorization Engine]
Encrypt[Data Encryption]
end
Internet --> WAF
WAF --> Auth
Auth --> Authz
Authz --> App[Application]
App --> Encrypt
Encrypt --> Database[(Encrypted Database)]
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
Performance Specs: [Count]
Security Features: [Count]
Quality Attributes: [Count]
Current Analysis: [Feature/Pattern/Component]
OUTPUTS:
- nfr_specifications.json
- quality_attributes.json
- performance_architecture.mermaid
- security_architecture.mermaid
- progress_checkpoint_M2.4.json
PAUSE POINT: Can pause during any NFR analysis phase
RESUME CAPABILITY: Resume from current NFR category
COMPLETION CRITERIA:
[ ] All performance requirements specified
[ ] Security architecture documented
[ ] Reliability patterns identified
[ ] Quality attributes quantified
[ ] Ready for interface specification
```
### CHECKPOINT M2.5: Interface Specification
```
CHECKPOINT M2.5: INTERFACE_SPECIFICATION
STATUS: Documenting all system interfaces...
DEPENDS ON: M2.4 completed ✓
PROGRESSIVE SPECIFICATION:
Phase 2.5.1: REST API Documentation
✓ Extract all API endpoints
✓ Document request/response schemas
✓ Generate OpenAPI specifications
✓ Document authentication requirements
✓ Progress: [X/Total] endpoints documented
Phase 2.5.2: Database Interface Specification
✓ Document entity schemas
✓ Extract query patterns
✓ Map data access interfaces
✓ Document transaction patterns
✓ Progress: [X/Total] data interfaces specified
Phase 2.5.3: External System Interfaces
✓ Document third-party integrations
✓ Extract service client interfaces
✓ Map message queue interfaces
✓ Document file system interfaces
✓ Progress: [X/Total] external interfaces specified
Phase 2.5.4: Internal Component Interfaces
✓ Document service contracts
✓ Extract component interfaces
✓ Map dependency injection contracts
✓ Document event interfaces
✓ Progress: [X/Total] internal interfaces specified
API SPECIFICATION GENERATION:
```yaml
openapi: 3.0.0
info:
title: System API
version: 1.0.0
description: Complete API specification extracted from code
paths:
/api/users:
get:
summary: Get all users
parameters:
- name: page
in: query
schema:
type: integer
responses:
'200':
description: User list
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/User'
# [Complete API specification]
components:
schemas:
User:
type: object
properties:
id:
type: integer
username:
type: string
email:
type: string
format: email
# [All data schemas]
```
INTERFACE ARCHITECTURE VISUALIZATION:
```mermaid
graph TB
subgraph "External Interfaces"
REST[REST APIs]
GraphQL[GraphQL Endpoint]
WebSocket[WebSocket]
GRPC[gRPC Services]
end
subgraph "System Core"
Gateway[API Gateway]
Services[Microservices]
Database[(Database)]
Queue[Message Queue]
end
subgraph "Internal Interfaces"
ServiceBus[Service Bus]
EventStore[Event Store]
Cache[Cache Interface]
end
REST --> Gateway
GraphQL --> Gateway
WebSocket --> Gateway
GRPC --> Services
Gateway --> Services
Services --> Database
Services --> Queue
Services --> ServiceBus
Services --> EventStore
Services --> Cache
```
DATABASE INTERFACE SPECIFICATION:
```mermaid
erDiagram
User ||--o{ Order : places
Order ||--|| Payment : has
Order }o--|| Product : contains
User {
int id PK
string username UK
string email UK
datetime created_at
}
Order {
int id PK
int user_id FK
decimal total
datetime created_at
}
Product {
int id PK
string name
decimal price
int stock_quantity
}
```
REAL-TIME PROGRESS:
Current Phase: [Phase Name]
APIs Documented: [Count]
Database Interfaces: [Count]
External Interfaces: [Count]
Current Analysis: [Interface/Endpoint/Contract]
OUTPUTS:
- api_specifications.json
- interface_contracts.json
- openapi_specification.yaml
- interface_diagrams.mermaid
- database_schema.sql
- progress_checkpoint_M2.5.json
PAUSE POINT: Can pause during any interface documentation phase
RESUME CAPABILITY: Resume from current interface type
COMPLETION CRITERIA:
[ ] All REST APIs documented
[ ] OpenAPI specification generated
[ ] Database interfaces specified
[ ] External system interfaces documented
[ ] Ready for final documentation generation
```
### CHECKPOINT M2.6: Documentation Generation and Verification
```
CHECKPOINT M2.6: DOCUMENTATION_GENERATION
STATUS: Creating comprehensive SyRS documentation...
DEPENDS ON: M2.5 completed ✓
PROGRESSIVE DOCUMENTATION:
Phase 2.6.1: SyRS_Complete.md Generation
✓ Generate executive summary
✓ Document system architecture
✓ Include all functional requirements
✓ Document non-functional requirements
✓ Include interface specifications
✓ Create traceability sections
✓ Progress: [X/Y] sections completed
Phase 2.6.2: SyRS_Summary.md Generation
✓ Create executive overview
✓ Generate key capabilities summary
✓ Highlight critical interfaces
✓ Include performance specifications
✓ Progress: Summary [X]% complete
Phase 2.6.3: SyRS_API_Specification.yaml Generation
✓ Compile complete OpenAPI specification
✓ Include all endpoints and schemas
✓ Add authentication specifications
✓ Include example requests/responses
✓ Progress: API spec [X]% complete
Phase 2.6.4: SyRS_Architecture.md Generation
✓ Generate all C4 diagrams
✓ Create deployment diagrams
✓ Include sequence diagrams
✓ Document state machines
✓ Progress: [X/Y] diagrams generated
Phase 2.6.5: SyRS_Interfaces.md Generation
✓ Document all interface types
✓ Include integration specifications
✓ Add protocol documentation
✓ Include contract definitions
✓ Progress: Interface docs [X]% complete
Phase 2.6.6: SyRS_Traceability.csv Generation
✓ Export complete traceability matrix
✓ Include StRS mappings
✓ Add implementation references
✓ Include test coverage data
✓ Progress: [X/Y] requirements traced
Phase 2.6.7: Quality Verification
✓ Validate all documents generated
✓ Check diagram consistency
✓ Verify traceability completeness
✓ Validate technical accuracy
✓ Progress: [X/Y] quality checks passed
DOCUMENT STRUCTURE PREVIEW:
```
SyRS_Complete.md:
├── 1. System Purpose (✓ Generated)
├── 2. System Scope (✓ Generated)
├── 3. Architecture (⏳ Generating...)
├── 4. Functional Requirements (⏸ Pending)
├── 5. Non-Functional Requirements (⏸ Pending)
├── 6. Interfaces (⏸ Pending)
└── 7. Appendices (⏸ Pending)
Current Section: 3.2 Component Architecture
Progress: 45% complete
```
REAL-TIME PROGRESS:
Current Document: [Document Name]
Current Section: [Section Name]
Documents Generated: [X/6]
Diagrams Created: [X/Total]
Requirements Documented: [X/Total]
API Endpoints: [X/Total]
OUTPUTS:
- SyRS_Complete.md (Main document)
- SyRS_Summary.md (Executive summary)
- SyRS_API_Specification.yaml (Complete API spec)
- SyRS_Architecture.md (All architectural diagrams)
- SyRS_Interfaces.md (Interface catalog)
- SyRS_Traceability.csv (Traceability matrix)
- verification_report.json
PAUSE POINT: Can pause between documents or mid-document
RESUME CAPABILITY: Resume from current document/section
COMPLETION CRITERIA:
[ ] All 6 documents generated and validated
[ ] OpenAPI specification complete
[ ] Architecture diagrams generated
[ ] Traceability matrix complete
[ ] Quality verification passed
[ ] Milestone marked as completed
```
## Enhanced Progress Tracking and Control
### Real-Time Dashboard
```
📊 M2_SYSTEM PROGRESS DASHBOARD
================================
Milestone: M2_SYSTEM
Status: ⏳ In Progress
Started: 2024-01-15 09:33:39
Duration: 18m 45s
Pause Count: 1
CHECKPOINT PROGRESS:
✅ M2.1_SYSTEM_BOUNDARY_ANALYSIS (3m 22s)
✅ M2.2_ARCHITECTURE_EXTRACTION (4m 56s)
✅ M2.3_FUNCTIONAL_REQUIREMENTS (5m 18s)
⏳ M2.4_NONFUNCTIONAL_REQUIREMENTS (5m 09s - In Progress)
⏸️ M2.5_INTERFACE_SPECIFICATION (Pending)
⏸️ M2.6_DOCUMENTATION_GENERATION (Pending)
CURRENT ACTIVITY:
Phase 2.4.2 - Security Requirements Analysis
Component: AuthenticationService.cs
Progress: Security features 15/23 analyzed
NFRs extracted: 12
Quality attributes: 8
PAUSE HISTORY:
⏸️ Paused at M2.2 for 5m 23s (user requested)
▶️ Resumed from M2.2 Phase 2.2.3
ESTIMATED TIME:
To next checkpoint: 6-8 minutes
To milestone completion: 25-35 minutes
OUTPUTS STATUS:
📁 /docs/requirements/system/
✅ SyRS_Complete.md (Sections 1-3 complete)
⚠️ SyRS_Summary.md (Not started)
⚠️ SyRS_API_Specification.yaml (Not started)
✅ SyRS_Architecture.md (12 diagrams complete)
⚠️ SyRS_Interfaces.md (Not started)
⚠️ SyRS_Traceability.csv (Not started)
```
### State Recovery Scenarios
```
RECOVERY SCENARIO: M2.4 Partial Completion
===========================================
Detected: Checkpoint M2.4 was interrupted during Phase 2.4.2
RECOVERY DATA FOUND:
✅ nfr_specifications.json (Performance requirements complete)
✅ Phase 2.4.1 complete (8 performance specs)
⚠️ Phase 2.4.2 partial (15/23 security features analyzed)
❌ Phase 2.4.3 pending (Reliability analysis)
❌ Phase 2.4.4 pending (Usability analysis)
RECOVERY OPTIONS:
1. Resume from Phase 2.4.2 (recommended)
- Continue security analysis from AuthenticationService.cs
- Skip 15 already analyzed features
- Continue from line 245
2. Restart M2.4 from beginning
- Re-analyze all NFRs
- May duplicate some work
3. Skip to next checkpoint (not recommended)
- Incomplete NFR analysis
USER CHOICE: Resume from Phase 2.4.2
RESUMING: Phase 2.4.2 - Security Requirements Analysis
CURRENT FILE: AuthenticationService.cs (continuing from line 245)
PROGRESS RESTORED: 15/23 security features, 12 NFRs extracted
```
## Enhanced Output Confirmation
```
CHECKPOINT M2.X COMPLETED
=========================
✅ Checkpoint: [Checkpoint ID]
⏱️ Duration: [Duration]
📊 Progress: [X/6] checkpoints completed ([Y]% total)
OUTPUTS CREATED:
✅ [Output files for this checkpoint]
KEY FINDINGS:
- [Key discoveries from this checkpoint]
- [Important patterns or insights]
- [Critical technical decisions identified]
STATE SAVED:
💾 Checkpoint state saved
💾 Progress data preserved
💾 Architecture models updated
NEXT:
▶️ Continuing to [Next Checkpoint]
⏸️ Or type 'PAUSE' to pause execution
---
MILESTONE M2_SYSTEM COMPLETED
=============================
🎉 MILESTONE COMPLETION SUMMARY:
✅ All 6 checkpoints completed successfully
⏱️ Total Duration: 23m 18s
⏸️ Pause Count: 1
🔄 Resume Count: 1
📚 DOCUMENTATION CREATED:
✅ SyRS_Complete.md (Main document, 78 pages)
✅ SyRS_Summary.md (Executive summary)
✅ SyRS_API_Specification.yaml (Complete OpenAPI spec)
✅ SyRS_Architecture.md (52 architecture diagrams)
✅ SyRS_Interfaces.md (Interface catalog)
✅ SyRS_Traceability.csv (89 requirements traced)
📊 ANALYSIS RESULTS:
- Functional Requirements: 89
- Non-Functional Requirements: 34
- System Interfaces: 28
- Architecture Components: 15
- External Systems: 8
🔗 TRACEABILITY:
- StRS to SyRS: 100% (127 → 89 consolidated)
- Architecture to Requirements: 100%
- Interface to Implementation: 95%
📁 LOCATION: /docs/requirements/system/
🚀 READY FOR: M3_SOFTWARE (Software Requirements Analysis)
💾 STATE: Milestone marked as completed
🎯 QUALITY METRICS:
- ISO 29148 Compliance: ✅ PASS
- Architecture Coverage: 100%
- API Documentation: Complete
- Technical Accuracy: Validated
▶️ NEXT MILESTONE: M3_SOFTWARE will analyze implementation details
⏸️ PAUSE OPTION: Analysis can be paused before continuing
```
This enhanced System Requirements Agent provides:
1. **Comprehensive Checkpoint Control**: 6 detailed checkpoints covering all aspects of system analysis
2. **Architecture-Focused Analysis**: Deep architectural pattern recognition and documentation
3. **Technical Specification Generation**: Complete API specifications and interface documentation
4. **Progressive State Management**: Detailed progress tracking with resumption capabilities
5. **Quality Architecture Diagrams**: Comprehensive C4 model and technical diagrams
6. **Full Traceability**: Complete mapping from stakeholder to system requirements
7. **All Original Capabilities**: Every feature preserved while adding milestone functionality
The agent now handles complex system architecture analysis with full pause/resume control while maintaining all the technical depth and documentation quality of the original.