@aicgen/aicgen 1.0.0-beta.1

package/data/index.md

@@ -0,0 +1,3 @@
+# aicgen Guidelines
+
+See [README.md](README.md) for full documentation and contribution guidelines.

package/data/language/csharp/basics.md

@@ -0,0 +1,210 @@
+# C# Fundamentals
+
+## Project Structure
+
+```
+MyProject/
+├── src/
+│   ├── MyProject.Api/
+│   │   ├── Controllers/
+│   │   ├── Program.cs
+│   │   └── MyProject.Api.csproj
+│   ├── MyProject.Core/
+│   │   ├── Entities/
+│   │   ├── Interfaces/
+│   │   └── Services/
+│   └── MyProject.Infrastructure/
+│       ├── Data/
+│       └── Services/
+├── tests/
+│   └── MyProject.Tests/
+└── MyProject.sln
+```
+
+## Naming Conventions
+
+```csharp
+// Classes, interfaces, methods: PascalCase
+public class UserService { }
+public interface IUserRepository { }
+public void CreateUser() { }
+
+// Interface prefix: I
+public interface IRepository { }
+
+// Private fields: _camelCase
+private readonly IUserRepository _repository;
+
+// Parameters, local variables: camelCase
+public User GetUser(string userId) { }
+
+// Constants: PascalCase
+public const int MaxRetries = 3;
+```
+
+## Modern C# Features (10+)
+
+```csharp
+// Records for immutable data
+public record User(string Id, string Email, string Name);
+
+// Pattern matching
+var result = obj switch
+{
+    User u when u.IsActive => "Active user",
+    User u => "Inactive user",
+    null => "No user",
+    _ => "Unknown"
+};
+
+// Null handling
+string? nullableString = GetValue();
+string nonNull = nullableString ?? "default";
+int length = nullableString?.Length ?? 0;
+
+// Target-typed new
+List<User> users = new();
+Dictionary<string, int> counts = new();
+
+// File-scoped namespaces
+namespace MyProject.Services;
+
+public class UserService { }
+```
+
+## Async/Await
+
+```csharp
+// Async methods return Task
+public async Task<User> GetUserAsync(string id)
+{
+    var user = await _repository.FindByIdAsync(id);
+    return user ?? throw new NotFoundException(id);
+}
+
+// Async enumerable
+public async IAsyncEnumerable<User> GetUsersAsync()
+{
+    await foreach (var user in _repository.StreamAsync())
+    {
+        yield return user;
+    }
+}
+
+// Cancellation
+public async Task ProcessAsync(CancellationToken ct)
+{
+    ct.ThrowIfCancellationRequested();
+    await _service.DoWorkAsync(ct);
+}
+```
+
+## LINQ
+
+```csharp
+// Query syntax
+var activeUsers = from u in users
+                  where u.IsActive
+                  orderby u.Name
+                  select u;
+
+// Method syntax (preferred)
+var emails = users
+    .Where(u => u.IsActive)
+    .OrderBy(u => u.Name)
+    .Select(u => u.Email)
+    .ToList();
+
+// Grouping
+var byDepartment = users
+    .GroupBy(u => u.Department)
+    .ToDictionary(g => g.Key, g => g.ToList());
+```
+
+## Exception Handling
+
+```csharp
+// Custom exceptions
+public class NotFoundException : Exception
+{
+    public NotFoundException(string id)
+        : base($"Entity not found: {id}") { }
+}
+
+// Try-catch-finally
+try
+{
+    await ProcessAsync();
+}
+catch (NotFoundException ex) when (ex.Message.Contains("user"))
+{
+    _logger.LogWarning(ex, "User not found");
+    throw;
+}
+catch (Exception ex)
+{
+    _logger.LogError(ex, "Unexpected error");
+    throw;
+}
+```
+
+## Dependency Injection
+
+```csharp
+// Service registration
+builder.Services.AddScoped<IUserRepository, UserRepository>();
+builder.Services.AddScoped<IUserService, UserService>();
+
+// Constructor injection
+public class UserService : IUserService
+{
+    private readonly IUserRepository _repository;
+    private readonly ILogger<UserService> _logger;
+
+    public UserService(IUserRepository repository, ILogger<UserService> logger)
+    {
+        _repository = repository;
+        _logger = logger;
+    }
+}
+```
+
+## Testing (xUnit)
+
+```csharp
+public class UserServiceTests
+{
+    private readonly Mock<IUserRepository> _repositoryMock;
+    private readonly UserService _sut;
+
+    public UserServiceTests()
+    {
+        _repositoryMock = new Mock<IUserRepository>();
+        _sut = new UserService(_repositoryMock.Object);
+    }
+
+    [Fact]
+    public async Task GetUser_WhenExists_ReturnsUser()
+    {
+        // Arrange
+        var user = new User("1", "test@example.com", "Test");
+        _repositoryMock.Setup(r => r.FindByIdAsync("1"))
+            .ReturnsAsync(user);
+
+        // Act
+        var result = await _sut.GetUserAsync("1");
+
+        // Assert
+        Assert.Equal("test@example.com", result.Email);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public async Task GetUser_WhenInvalidId_ThrowsArgumentException(string id)
+    {
+        await Assert.ThrowsAsync<ArgumentException>(
+            () => _sut.GetUserAsync(id));
+    }
+}
+```

package/data/language/csharp/testing.md

@@ -0,0 +1,252 @@
+# C# Testing (xUnit)
+
+## Test Structure
+
+```
+MyProject/
+├── src/
+│   └── MyProject/
+│       └── Services/UserService.cs
+└── tests/
+    └── MyProject.Tests/
+        └── Services/UserServiceTests.cs
+```
+
+## Basic Tests
+
+```csharp
+using Xunit;
+
+public class UserServiceTests
+{
+    private readonly UserService _sut; // System Under Test
+
+    public UserServiceTests()
+    {
+        _sut = new UserService();
+    }
+
+    [Fact]
+    public void Create_WithValidEmail_ReturnsUser()
+    {
+        var user = _sut.Create("test@example.com");
+
+        Assert.NotNull(user);
+        Assert.Equal("test@example.com", user.Email);
+    }
+
+    [Fact]
+    public void Create_WithInvalidEmail_ThrowsValidationException()
+    {
+        Assert.Throws<ValidationException>(() => _sut.Create("invalid"));
+    }
+}
+```
+
+## Assertions
+
+```csharp
+// Equality
+Assert.Equal(expected, actual);
+Assert.NotEqual(unexpected, actual);
+
+// Boolean
+Assert.True(condition);
+Assert.False(condition);
+
+// Null
+Assert.Null(value);
+Assert.NotNull(value);
+
+// Collections
+Assert.Empty(collection);
+Assert.NotEmpty(collection);
+Assert.Contains(item, collection);
+Assert.DoesNotContain(item, collection);
+Assert.All(collection, item => Assert.NotNull(item.Name));
+
+// Type
+Assert.IsType<User>(result);
+Assert.IsAssignableFrom<IEntity>(result);
+
+// Exceptions
+var ex = Assert.Throws<NotFoundException>(() => service.Find("invalid"));
+Assert.Equal("User not found", ex.Message);
+```
+
+## Theory Tests (Parameterized)
+
+```csharp
+[Theory]
+[InlineData("test@example.com", true)]
+[InlineData("invalid", false)]
+[InlineData("", false)]
+public void IsValidEmail_WithVariousInputs_ReturnsExpected(string email, bool expected)
+{
+    var result = _validator.IsValid(email);
+    Assert.Equal(expected, result);
+}
+
+[Theory]
+[MemberData(nameof(GetTestUsers))]
+public void ProcessUser_WithVariousUsers_ReturnsExpected(User user, string expectedStatus)
+{
+    var result = _processor.Process(user);
+    Assert.Equal(expectedStatus, result);
+}
+
+public static IEnumerable<object[]> GetTestUsers()
+{
+    yield return new object[] { new User("active@example.com") { IsActive = true }, "processed" };
+    yield return new object[] { new User("inactive@example.com") { IsActive = false }, "skipped" };
+}
+```
+
+## Test Classes and Collections
+
+```csharp
+// Shared context across tests in a class
+public class UserServiceTests : IClassFixture<DatabaseFixture>
+{
+    private readonly DatabaseFixture _fixture;
+
+    public UserServiceTests(DatabaseFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    [Fact]
+    public void Test1() { /* uses _fixture */ }
+}
+
+// Shared context across multiple test classes
+[CollectionDefinition("Database")]
+public class DatabaseCollection : ICollectionFixture<DatabaseFixture> { }
+
+[Collection("Database")]
+public class UserServiceTests { }
+
+[Collection("Database")]
+public class OrderServiceTests { }
+```
+
+## Mocking with Moq
+
+```csharp
+using Moq;
+
+public class UserServiceTests
+{
+    private readonly Mock<IUserRepository> _repositoryMock;
+    private readonly Mock<ILogger<UserService>> _loggerMock;
+    private readonly UserService _sut;
+
+    public UserServiceTests()
+    {
+        _repositoryMock = new Mock<IUserRepository>();
+        _loggerMock = new Mock<ILogger<UserService>>();
+        _sut = new UserService(_repositoryMock.Object, _loggerMock.Object);
+    }
+
+    [Fact]
+    public async Task GetUser_WhenExists_ReturnsUser()
+    {
+        // Arrange
+        var user = new User("1", "test@example.com");
+        _repositoryMock.Setup(r => r.FindByIdAsync("1"))
+            .ReturnsAsync(user);
+
+        // Act
+        var result = await _sut.GetUserAsync("1");
+
+        // Assert
+        Assert.Equal("test@example.com", result.Email);
+        _repositoryMock.Verify(r => r.FindByIdAsync("1"), Times.Once);
+    }
+
+    [Fact]
+    public async Task GetUser_WhenNotFound_ThrowsNotFoundException()
+    {
+        _repositoryMock.Setup(r => r.FindByIdAsync(It.IsAny<string>()))
+            .ReturnsAsync((User?)null);
+
+        await Assert.ThrowsAsync<NotFoundException>(
+            () => _sut.GetUserAsync("invalid"));
+    }
+}
+```
+
+## Async Testing
+
+```csharp
+[Fact]
+public async Task CreateAsync_WithValidData_ReturnsUser()
+{
+    var user = await _sut.CreateAsync("test@example.com");
+
+    Assert.NotNull(user);
+    Assert.Equal("test@example.com", user.Email);
+}
+
+[Fact]
+public async Task CreateAsync_WithTimeout_CompletesInTime()
+{
+    var task = _sut.CreateAsync("test@example.com");
+    var completed = await Task.WhenAny(task, Task.Delay(5000)) == task;
+
+    Assert.True(completed, "Operation timed out");
+}
+```
+
+## Test Output
+
+```csharp
+public class UserServiceTests
+{
+    private readonly ITestOutputHelper _output;
+
+    public UserServiceTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    [Fact]
+    public void Test_WithLogging()
+    {
+        _output.WriteLine("Starting test...");
+        // test logic
+        _output.WriteLine($"Result: {result}");
+    }
+}
+```
+
+## Integration Testing with WebApplicationFactory
+
+```csharp
+public class UserApiTests : IClassFixture<WebApplicationFactory<Program>>
+{
+    private readonly HttpClient _client;
+
+    public UserApiTests(WebApplicationFactory<Program> factory)
+    {
+        _client = factory.WithWebHostBuilder(builder =>
+        {
+            builder.ConfigureServices(services =>
+            {
+                // Replace real services with test doubles
+                services.AddScoped<IUserRepository, InMemoryUserRepository>();
+            });
+        }).CreateClient();
+    }
+
+    [Fact]
+    public async Task GetUser_ReturnsUser()
+    {
+        var response = await _client.GetAsync("/api/users/1");
+
+        response.EnsureSuccessStatusCode();
+        var user = await response.Content.ReadFromJsonAsync<User>();
+        Assert.Equal("test@example.com", user?.Email);
+    }
+}
+```

package/data/language/go/basics.md

@@ -0,0 +1,158 @@
+# Go Fundamentals
+
+## Project Structure
+
+```
+myproject/
+├── cmd/
+│   └── myapp/
+│       └── main.go       # Application entry point
+├── internal/             # Private application code
+│   ├── handler/
+│   ├── service/
+│   └── repository/
+├── pkg/                  # Public library code
+├── go.mod
+└── go.sum
+```
+
+## Naming Conventions
+
+```go
+// Package names: lowercase, single word
+package user
+
+// Exported (public): PascalCase
+func CreateUser() {}
+type UserService struct {}
+
+// Unexported (private): camelCase
+func validateEmail() {}
+type userCache struct {}
+
+// Interfaces: -er suffix when possible
+type Reader interface {}
+type UserRepository interface {}
+
+// Constants: PascalCase for exported
+const MaxRetries = 3
+const defaultTimeout = 30
+```
+
+## Error Handling
+
+```go
+// Always check errors
+result, err := doSomething()
+if err != nil {
+    return fmt.Errorf("failed to do something: %w", err)
+}
+
+// Custom errors
+var ErrNotFound = errors.New("not found")
+var ErrInvalidInput = errors.New("invalid input")
+
+// Error wrapping for context
+if err != nil {
+    return fmt.Errorf("creating user %s: %w", name, err)
+}
+
+// Errors.Is and errors.As for checking
+if errors.Is(err, ErrNotFound) {
+    // Handle not found
+}
+```
+
+## Concurrency
+
+```go
+// Goroutines for concurrent work
+go func() {
+    // Concurrent task
+}()
+
+// Channels for communication
+ch := make(chan int)
+ch <- value    // Send
+value := <-ch  // Receive
+
+// Context for cancellation
+ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+defer cancel()
+
+// sync.WaitGroup for coordination
+var wg sync.WaitGroup
+wg.Add(1)
+go func() {
+    defer wg.Done()
+    // Work
+}()
+wg.Wait()
+```
+
+## Testing
+
+```go
+// Test file: user_test.go
+func TestCreateUser(t *testing.T) {
+    // Arrange
+    svc := NewUserService()
+
+    // Act
+    user, err := svc.Create("test@example.com")
+
+    // Assert
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    if user.Email != "test@example.com" {
+        t.Errorf("got %s, want test@example.com", user.Email)
+    }
+}
+
+// Table-driven tests
+func TestValidateEmail(t *testing.T) {
+    tests := []struct {
+        name  string
+        email string
+        valid bool
+    }{
+        {"valid", "test@example.com", true},
+        {"no at", "invalid", false},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got := ValidateEmail(tt.email)
+            if got != tt.valid {
+                t.Errorf("ValidateEmail(%q) = %v, want %v", tt.email, got, tt.valid)
+            }
+        })
+    }
+}
+```
+
+## Common Patterns
+
+```go
+// Functional options
+type Option func(*Config)
+
+func WithTimeout(d time.Duration) Option {
+    return func(c *Config) { c.Timeout = d }
+}
+
+func NewClient(opts ...Option) *Client {
+    cfg := defaultConfig()
+    for _, opt := range opts {
+        opt(&cfg)
+    }
+    return &Client{config: cfg}
+}
+
+// Interface-based design
+type UserRepository interface {
+    FindByID(ctx context.Context, id string) (*User, error)
+    Save(ctx context.Context, user *User) error
+}
+```