AimAssist Context

Provides comprehensive development context for working with the AimAssist WPF command launcher application. This skill helps you understand the project architecture, common commands, and key patterns when modifying or extending the codebase.

Project Overview

AimAssist is a WPF-based command launcher and productivity tool built on .NET, featuring:

Architecture Guidance

When working with this codebase, follow these architectural patterns:

1. Understand the Project Structure

The solution is organized into distinct layers:

2. Follow the Dependency Injection Pattern

Services are registered through 7 specialized modules in `App.xaml.cs`:

Always inject dependencies through constructors. Use `IMainWindow` interface instead of concrete `MainWindow` class for better testability.

3. Implement the Unit-Based Architecture

When adding new features, create units implementing `IUnit`:

```csharp

[AutoRegisterUnit("CategoryName", Priority = 100, IsEnabled = true)]

public class MyUnit : IUnit

{

public IMode Mode { get; }

public string Name { get; }

public string Description { get; }

public string Category { get; }

}

```

Units are automatically discovered and registered through `ReflectionBasedUnitsFactory` or specialized factories:

Units are displayed in order: Mode display order → IUnit/IFeature type (IUnit=0, IFeature=1) → Category → Name

4. Maintain MVVM Separation

5. Work with Key Integrations

**Monaco Editor** (Common.UI.Editor):

**Speech Recognition**:

**MEF Plugins**:

**LLM Integration**:

Common Development Commands

**Build and Test:**

```bash

Build solution

dotnet build AimAssist.sln

Run tests

dotnet test src/AimAssist/AimAssist.Tests/

Run application

dotnet run --project src/AimAssist/AimAssist/

Publish Windows x64 release

dotnet publish src/AimAssist/AimAssist/ -c Release --self-contained true -r win-x64

```

Key Implementation Notes

**Display Order Logic**: Units are sorted by Mode display order → IUnit/IFeature type → Category → Name. This ordering is enforced in `MainWindowViewModel.LoadUnitsForMode` and `ReflectionBasedUnitsFactory`.

**Service Consistency**: All IUnit-related processing comes before IFeature-related processing throughout the codebase (interfaces, services, factories).

**ComputerView Optimization**: Timer-based updates removed. Data is loaded on-demand when tabs are selected for minimal CPU usage.

**AimAssistCommandsControl**: Dynamically generates buttons for all `IAppCommands` using reflection, with Japanese display name mapping.

**GitHub Actions**: Automated release workflows with caching, versioning, self-contained builds, and detailed release notes.

Instructions

1. **Before making changes**: Read the relevant project files to understand current implementation

2. **Follow existing patterns**: Match the DI, Factory, and MVVM patterns used throughout

3. **Use interfaces**: Prefer `IMainWindow` over `MainWindow`, inject services via constructors

4. **Auto-register units**: Use `[AutoRegisterUnit]` attribute for new units

5. **Maintain sort order**: Ensure new units follow Mode → Type → Category → Name ordering

6. **Test thoroughly**: Add xUnit tests with Moq for new services

7. **Document changes**: Update CLAUDE.md "最新の変更" section with significant modifications

8. **Respect architecture**: Keep business logic in services, UI logic in ViewModels, presentation in Views

9. **Handle errors gracefully**: Use error handling services, don't throw unhandled exceptions

10. **Optimize performance**: Avoid timers and background processing where on-demand loading suffices