@moon791017/neo-skills 1.0.1

package/skills/azure-pipelines/templates/util/set-aspnetcore-env.yml

@@ -0,0 +1,77 @@
+# ==============================================================================
+# Template Name: Set ASP.NET Core Environment (set-aspnetcore-env.yml)
+# Description: 
+#   Modify web.config before deployment to inject or update the ASPNETCORE_ENVIRONMENT environment variable.
+#   This ensures the application starts with the correct environment settings, avoiding a second restart.
+# ==============================================================================
+
+parameters:
+  - name: aspNetCoreEnvironment
+    type: string
+  - name: packagePath
+    type: string
+  
+  # Execution Condition
+  - name: runCondition
+    type: string
+    default: 'succeeded()'
+
+steps:
+  - powershell: |
+      $envValue = "${{ parameters.aspNetCoreEnvironment }}"
+      $packagePath = "${{ parameters.packagePath }}"
+      
+      Write-Host "Target Package Path: $packagePath"
+      
+      # Check if path exists and is a directory
+      if (Test-Path $packagePath -PathType Container) {
+          $webConfigPath = Get-ChildItem -Path $packagePath -Filter "web.config" -Recurse | Select-Object -First 1
+          
+          if ($webConfigPath) {
+              Write-Host "Found web.config at: $($webConfigPath.FullName)"
+              
+              # Read XML
+              $xml = [xml](Get-Content $webConfigPath.FullName)
+              
+              # Use XPath to find aspNetCore node, ignoring structure differences (e.g. wrapped in <location>)
+              $aspNetCore = $xml.SelectSingleNode("//system.webServer/aspNetCore")
+
+              if ($aspNetCore) {
+                  # Ensure environmentVariables node exists
+                  if (-not $aspNetCore.SelectSingleNode("environmentVariables")) {
+                      Write-Host "Creating environmentVariables node..."
+                      $envVars = $xml.CreateElement("environmentVariables")
+                      $aspNetCore.AppendChild($envVars) | Out-Null
+                  }
+                  
+                  # Get environmentVariables node (Use SelectSingleNode to ensure XmlElement)
+                  $envVarsNode = $aspNetCore.SelectSingleNode("environmentVariables")
+
+                  # Check if variable exists, remove old one if so
+                  $existing = $envVarsNode.SelectSingleNode("environmentVariable[@name='ASPNETCORE_ENVIRONMENT']")
+                  if ($existing) {
+                      Write-Host "Removing existing ASPNETCORE_ENVIRONMENT setting..."
+                      $envVarsNode.RemoveChild($existing) | Out-Null
+                  }
+                  
+                  # Create new environment variable node
+                  Write-Host "Injecting ASPNETCORE_ENVIRONMENT='$envValue'..."
+                  $newEnv = $xml.CreateElement("environmentVariable")
+                  $newEnv.SetAttribute("name", "ASPNETCORE_ENVIRONMENT")
+                  $newEnv.SetAttribute("value", $envValue)
+                  $envVarsNode.AppendChild($newEnv) | Out-Null
+                  
+                  # Save
+                  $xml.Save($webConfigPath.FullName)
+                  Write-Host "web.config updated successfully."
+              } else {
+                  Write-Warning "Element system.webServer/aspNetCore not found in web.config (XPath: //system.webServer/aspNetCore). Skipping."
+              }
+          } else {
+              Write-Warning "web.config not found in artifact. Skipping environment variable injection."
+          }
+      } else {
+          Write-Warning "Artifact path is not a directory (possibly a ZIP file?). Cannot modify web.config directly."
+      }
+    displayName: 'Pre-modify web.config (Inject Environment Variable)'
+    condition: ${{ parameters.runCondition }}

package/skills/clarification/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: clarification
+description: 系統化引導使用者釐清模糊需求，並將其轉換為結構化的規格文件。
+---
+
+# Requirement Clarification Assistant
+
+## Perceive
+1. Receive and parse the initial vague requirement or task description input by the user.
+2. Identify the professional domain context of the task (e.g., software development, business workflow, content creation).
+3. Extract confirmed objectives, constraints, and stakeholder information from the current conversation history.
+
+## Reason
+1. Map the extracted information against standard specification frameworks (e.g., 5W1H model or SMART criteria).
+2. Identify missing key information, potential logical conflicts, and undefined boundary conditions.
+3. Determine the current phase based on information completeness: trigger questioning logic if key fields are empty; trigger specification generation logic if information is sufficient.
+4. Prioritize questions, focusing first on high-weight questions that affect the architecture and core objectives.
+
+## Act
+1. Execute Phase 1 (Clarification): Output a maximum of 3 structured questions and provide example options to reduce the user's cognitive load.
+2. Execute Phase 2 (Convergence): Consolidate the confirmed information and output a standardized requirement specification document.
+3. Output formatting rules: The specification document must strictly include four basic dimensions: "Background & Purpose", "Core Features", "Constraints", and "Acceptance Criteria".

package/skills/code-review/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: code-review-architect
+description: 分析程式碼變更，從安全性、效能與風格等多個面向找出問題、潛在 Bug 與改善空間。
+---
+
+# Code Review Specifications
+
+## Perceive (Analysis Phase)
+1. **Scope Identification**:
+   - Analyze the provided code diffs or file contents.
+   - Identify the languages and frameworks involved (e.g., TypeScript, C#, Python, React).
+   - Determine the nature of the change (e.g., Feature, Bugfix, Refactor, Config).
+
+2. **Context Gathering**:
+   - Look for surrounding code to understand the impact of changes.
+   - Check for relevant configuration files (e.g., `tsconfig.json`, `.eslintrc`, security policies) if available in the provided context.
+
+## Reason (Evaluation Phase)
+Evaluate the code against the following dimensions:
+
+1.  **Correctness & Logic**:
+    - Does the code do what it's supposed to do?
+    - Are there any edge cases missing?
+    - Are there potential concurrency issues (race conditions, deadlocks)?
+
+2.  **Security (Critical)**:
+    - **Injection Flaws**: SQLi, XSS, Command Injection.
+    - **Data Exposure**: Hardcoded secrets, sensitive data logging.
+    - **Auth**: Improper authentication or authorization checks.
+    - **Dependencies**: Use of known insecure functions or patterns.
+
+3.  **Performance**:
+    - **Efficiency**: Algorithmic complexity (Big O).
+    - **Resources**: Memory leaks, unclosed file handles/connections.
+    - **Database**: N+1 queries, missing indexes.
+
+4.  **Maintainability & Readability**:
+    - **Clarity**: Variable/function naming, comment quality.
+    - **Complexity**: Cyclomatic complexity, function length.
+    - **Modularity**: DRY (Don't Repeat Yourself), SOLID principles.
+    - **Testing**: Is the code testable? Are tests included?
+
+5.  **Style & Standards**:
+    - Adherence to language-specific conventions (e.g., PEP8 for Python, Airbnb for JS).
+    - Consistency with the existing project style.
+
+## Act (Reporting Phase)
+Generate a structured Code Review Report in **Traditional Chinese (Taiwan)** with the following sections:
+
+1.  **🔍 審查摘要 (Summary)**:
+    - Brief overview of the changes.
+    - Overall assessment (e.g., "Ready to merge", "Needs changes", "Major rework needed").
+
+2.  **🔴 嚴重問題 (Critical Issues)**:
+    - **Must-fix** items (Security vulnerabilities, Logic bugs, Breaking changes).
+    - Clear explanation of *why* it is critical.
+
+3.  **🟡 改進建議 (Suggestions)**:
+    - Performance improvements.
+    - Refactoring opportunities (Clean Code).
+    - Edge case handling.
+
+4.  **🟢 優秀之處 (Praise)** (Optional):
+    - Highlight well-written code or clever solutions.
+
+5.  **❓ 疑問 (Questions)** (Optional):
+    - Clarification needed on business logic or intent.
+
+**Style Guidelines for the Report**:
+- Be constructive and respectful.
+- Use code snippets to illustrate the problem or suggested fix.
+- Focus on the *code*, not the *coder*.

package/skills/csharp/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: csharp
+version: "1.4.0"
+category: "Core"
+description: "跨版本 C# 專家技能 (10, 11, 12, 13, 14+)。支援從 .NET 6 (LTS) 到 .NET 10 (LTS) 的現代開發模式，涵蓋 File-scoped namespaces 到 Extension Types 的全方位演進。"
+compatibility: "Supports C# 10 through 14. Adaptive to .NET 6.0, 7.0, 8.0, 9.0, and 10.0 environments."
+---
+
+# Modern C# (10+) Expert Skill
+
+## Trigger On
+- The user asks to write, debug, refactor, or review C# code.
+- The project directory contains `*.cs`, `*.csproj`, or single-file C# scripts.
+- The target framework is .NET 6.0 (LTS) and above.
+- Code modernization is needed (e.g., converting legacy nested namespaces to File-scoped namespaces).
+
+## Workflow
+1. **Perceive (Version Awareness):**
+   - Check `.csproj` to identify `TargetFramework` and determine the syntax upper limit:
+     - `net6.0`: C# 10 (File-scoped namespaces, Global usings).
+     - `net7.0`: C# 11 (Raw string literals, Required members).
+     - `net8.0`: C# 12 (Primary Constructors, Collection Expressions).
+     - `net9.0`: C# 13 (`params` collections, `Lock` object).
+     - `net10.0`: C# 14 (Extension members, `field` keyword).
+2. **Reason (Planning Phase):**
+   - Evaluate the modernization level of the current code to determine the refactoring strategy.
+   - In lower version environments (like .NET 6), avoid using higher version syntax (like Primary Constructors), but prioritize using File-scoped namespaces.
+   - In higher version environments, actively adopt new features to reduce boilerplate code.
+3. **Act (Execution Phase):**
+   - Write high-quality code, prioritizing "syntactic sugar" to improve readability.
+   - Implement strong typing and immutable data structures (`record`, `record struct`).
+   - Utilize **Interpolated string handlers** and **Span<T>** to optimize performance-sensitive paths.
+4. **Validate (Standard Validation):**
+   - Validate the safety of NRT (Nullable Reference Types).
+   - Check if asynchronous operations correctly handle cancellation tokens (`CancellationToken`).
+   - Ensure naming conventions comply with official .NET recommendations.
+
+## Feature Roadmap (C# 10 - 14)
+
+### C# 10 & 11 (Foundation)
+- **File-scoped Namespaces:** Reduce indentation levels.
+- **Global Using Directives:** Centralize common namespaces management.
+- **Raw String Literals:** `"""..."""` easily handle multi-line and special characters.
+- **Required Members:** Ensure required properties during object initialization.
+- **List Patterns:** `if (list is [1, 2, ..])` powerful collection matching.
+
+### C# 12 & 13 (Productivity)
+- **Primary Constructors:** Simplify class-level dependency injection.
+- **Collection Expressions:** Uniformly use `[1, 2, 3]` to initialize collections.
+- **`params` Collections:** Method parameters support various collection types.
+- **Implicit Span Conversion:** Handle memory-safe code more naturally.
+
+### C# 14+ (Cutting Edge)
+- **Extension Members:** Extension properties, operators, and static members.
+- **`field` Keyword:** Directly access backing fields in property logic.
+- **Null-conditional Assignment:** `target?.Property = value;`.
+- **Scripting:** Support `dotnet run file.cs` for direct execution.
+
+## Coding Standards
+- **Clean Structure:** Prioritize using File-scoped namespaces.
+- **Immutability:** Use `record` for Data Transfer Objects (DTO).
+- **Performance:** Use `Span<T>` and `ReadOnlySpan<char>` in critical paths.
+- **Async Safety:** Always pass `CancellationToken`, avoid `.Result` or `.Wait()`.
+
+## Deliver
+- **Version-Optimized Code:** Provide the most appropriate modernized syntax code based on the target C# version.
+- **Modernization Insights:** Provide specific refactoring suggestions for upgrading from older C# syntax to new features (e.g., from nested namespaces to File-scoped namespaces).
+- **Syntax Explanations:** Clearly explain the design intent and syntax advantages behind the new C# features used.
+
+## Validate
+- Ensure the provided code complies with the syntax specifications of the target C# version.
+- Validate whether the code follows C# strong typing and Null safety (NRT) principles.
+- Confirm the code has good readability and best practices at the pure C# language level (e.g., proper use of `Span<T>`, `record`, etc.).
+
+## Documentation
+### Official References
+- [What's new in C# 14 (Extension Members, field keyword)](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14)
+- [What's new in C# 13 (params collections, Lock object)](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-13)
+- [What's new in C# 12 (Primary Constructors, Collection Expressions)](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-12)
+- [What's new in C# 11 (Raw String Literals, Required Members)](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-version-history#c-version-11)
+- [What's new in C# 10 (File-scoped Namespaces, Global Usings)](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-version-history#c-version-10)
+- [Nullable Reference Types](https://learn.microsoft.com/en-us/dotnet/csharp/nullable-references)
+
+### Internal References
+- [C# Coding Style and Naming Conventions Guide](reference/coding-style.md)
+- [C# Anti-Patterns and Best Practices](reference/anti-patterns.md)
+- [Modern C# Patterns Guide](reference/patterns.md)

package/skills/csharp/reference/anti-patterns.md

@@ -0,0 +1,142 @@
+# C# Anti-Patterns & Best Practices
+
+This document lists common mistakes (Anti-Patterns) in C# development and their corresponding correct practices (Best Practices).
+
+## 1. Asynchronous Programming
+
+### 1.1 Avoid `Sync over Async`
+**Problem**: Using `.Result` or `.Wait()` blocks the thread and can easily lead to deadlocks in ASP.NET or UI applications.
+
+- **Bad**:
+  ```csharp
+  public IActionResult Get()
+  {
+      var data = _service.GetDataAsync().Result; // May cause deadlock
+      return Ok(data);
+  }
+  ```
+- **Good**:
+  ```csharp
+  public async Task<IActionResult> Get(CancellationToken ct)
+  {
+      var data = await _service.GetDataAsync(ct);
+      return Ok(data);
+  }
+  ```
+
+### 1.2 Avoid `async void`
+**Problem**: `async void` methods cannot be `await`ed, and exceptions thrown within them cannot be caught by the caller, leading to direct process crashes.
+
+- **Bad**:
+  ```csharp
+  public async void ProcessDataAsync() { ... }
+  ```
+- **Good**:
+  ```csharp
+  public async Task ProcessDataAsync() { ... } // Unless it's an Event Handler
+  ```
+
+---
+
+## 2. Memory & Performance
+
+### 2.1 Avoid string concatenation in loops
+**Problem**: Strings are immutable, so every `+` creates a new string object, causing massive memory allocations.
+
+- **Bad**:
+  ```csharp
+  string result = "";
+  foreach (var s in items) { result += s; }
+  ```
+- **Good**:
+  ```csharp
+  var sb = new StringBuilder();
+  foreach (var s in items) { sb.Append(s); }
+  string result = sb.ToString();
+  ```
+
+### 2.2 Leverage `Span<T>` and `ReadOnlySpan<T>`
+**Problem**: Frequent use of `Substring` creates substring copies.
+
+- **Bad**:
+  ```csharp
+  string sub = largeString.Substring(0, 10);
+  ```
+- **Good**:
+  ```csharp
+  ReadOnlySpan<char> span = largeString.AsSpan(0, 10); // No copy allocation needed
+  ```
+
+---
+
+## 3. Exception Handling
+
+### 3.1 Avoid swallowing exceptions
+**Problem**: Catching exceptions without handling or logging them hides potential bugs, making debugging extremely difficult.
+
+- **Bad**:
+  ```csharp
+  try { ... } catch (Exception) { } // Do nothing
+  ```
+- **Good**:
+  ```csharp
+  try { ... } 
+  catch (Exception ex) 
+  { 
+      _logger.LogError(ex, "An error occurred"); 
+      throw; // Or handle according to logic
+  }
+  ```
+
+### 3.2 Rethrow exceptions correctly
+**Problem**: Using `throw ex;` clears the original stack trace.
+
+- **Bad**:
+  ```csharp
+  catch (Exception ex) { throw ex; }
+  ```
+- **Good**:
+  ```csharp
+  catch (Exception ex) { throw; } // Preserve original stack trace
+  ```
+
+---
+
+## 4. Modern C# Patterns
+
+### 4.1 Null checks (C# 9.0+)
+- **Legacy**: `if (obj != null)`
+- **Modern**: `if (obj is not null)` (Clearer semantics, unaffected by `!=` operator overloading)
+
+### 4.2 Collection initialization (C# 12+)
+- **Legacy**: `var list = new List<int> { 1, 2, 3 };`
+- **Modern**: `List<int> list = [1, 2, 3];` (Using Collection Expressions)
+
+### 4.3 Property backing fields (C# 14+)
+- **Legacy**:
+  ```csharp
+  private string _name;
+  public string Name { get => _name; set => _name = value.Trim(); }
+  ```
+- **Modern**:
+  ```csharp
+  public string Name { get; set => field = value.Trim(); } // Using the field keyword
+  ```
+
+---
+
+## 5. Resource Management
+
+### 5.1 Always use `using` declarations
+**Problem**: Failing to properly release objects implementing `IDisposable` (like database connections, file streams) leads to resource leaks.
+
+- **Bad**:
+  ```csharp
+  var stream = new FileStream(path, FileMode.Open);
+  // ... If an exception occurs in between, stream is never closed
+  stream.Dispose();
+  ```
+- **Good**:
+  ```csharp
+  using var stream = new FileStream(path, FileMode.Open); // Automatically Disposed at end of scope
+  ```

package/skills/csharp/reference/coding-style.md

@@ -0,0 +1,86 @@
+# C# Coding Conventions
+
+This guide is based on Microsoft's official [C# Coding Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions) and [C# Naming Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/coding-style/naming-conventions), aimed at improving development efficiency and maintaining project consistency.
+
+## 1. Naming Conventions
+
+Good naming is the core of self-documenting code and reduces communication overhead.
+
+### 1.1 PascalCase
+Used for **public members** and **type names**.
+- **Class & Struct**: `public class OrderManager`
+- **Interface**: Must start with a capital **`I`**, e.g., `public interface IRepository`
+- **Property**: `public string FullName { get; set; }`
+- **Method**: `public void ExecuteTask()`
+- **Enum**: `public enum OrderStatus`
+
+### 1.2 camelCase
+Used for **internal, local, or private members**.
+- **Local Variable**: `var totalCount = 0;`
+- **Parameter**: `public void UpdateUser(int userId)`
+- **Private Field**: **Must have an underscore prefix `_`**. This instantly distinguishes it as class state rather than a local variable or parameter.
+  - Recommended: `private readonly ILogger _logger;`
+
+---
+
+## 2. File Organization
+
+- **File name matching**: The file name must match the primary type name (e.g., `CustomerService.cs` should contain `class CustomerService`).
+- **Single Responsibility**: In principle, **one file should define only one type** (Class, Interface, Enum) to facilitate version control and code search.
+- **Namespace**:
+  - Prioritize **File-scoped Namespace** (C# 10+) to reduce indentation levels:
+    ```csharp
+    namespace MyProject.Services; // Recommended (C# 10+)
+    ```
+
+---
+
+## 3. Formatting
+
+### 3.1 Allman Style (Braces on new line)
+The opening brace `{` must be on its own line, aligned with the class, method, or control statement. This is the standard C# style.
+```csharp
+// Correct approach
+public void Process()
+{
+    if (isReady)
+    {
+        DoWork();
+    }
+}
+```
+
+### 3.2 Indentation and Spacing
+- **Indentation**: Fixed at **4 spaces**. The use of Tab characters is strictly prohibited to ensure consistent display across platforms.
+- **Blank lines**: Leave one blank line between methods; use a single blank line to separate logical blocks within a method.
+
+---
+
+## 4. Asynchronous Programming
+
+- **Async Suffix**: All asynchronous methods returning `Task` or `ValueTask` must end with the **`Async`** suffix.
+- **CancellationToken**: Asynchronous methods should prioritize accepting a `CancellationToken` parameter and pass it to downstream asynchronous operations.
+```csharp
+public async Task<User?> GetUserByIdAsync(int id, CancellationToken ct = default)
+{
+    return await _context.Users.FindAsync([id], ct);
+}
+```
+
+---
+
+## 5. Modern C# Best Practices
+
+- **Type Inference (var)**: When the variable type is obvious from the right side of the assignment (like `new`, casting), use `var`.
+  - Recommended: `var users = new List<User>();`
+- **Null Checks**: Use `is not null` for checking, as the semantics are closer to natural language and bypass operator overloading.
+  - Recommended: `if (input is not null) { ... }`
+- **Object Initialization**: Prioritize using object initializers and collection expressions (C# 12+).
+  - Recommended: `List<int> numbers = [1, 2, 3];`
+
+---
+
+## 6. Commenting Conventions
+
+- **XML Comments**: Public APIs must use `///` to provide XML comments so IDEs can show IntelliSense descriptions.
+- **Logical Comments**: Comments should explain "Why" the processing is done this way, rather than repeating "What" the code does.

package/skills/csharp/reference/patterns.md

@@ -0,0 +1,142 @@
+# Modern C# Patterns Guide
+
+This document introduces recommended development patterns in C# 10 through 14+, aiming to simplify code and improve performance using modern syntax.
+
+## 1. Architecture and Declaration Patterns
+
+### 1.1 File-scoped Namespaces (C# 10+)
+**Recommendation**: Reduce brace nesting to make the code structure flatter.
+```csharp
+namespace MyProject.Services; // Recommended
+
+public class CustomerService { ... }
+```
+
+### 1.2 Primary Constructors (C# 12+)
+**Recommendation**: Simplify class-level dependency injection declarations.
+```csharp
+// Declare parameters directly after the class name to initialize properties or fields
+public class UserService(IUserRepository repository, ILogger logger)
+{
+    public async Task<User?> GetUserAsync(int id) => await repository.FindByIdAsync(id);
+}
+```
+
+---
+
+## 2. Data Structures and Initialization
+
+### 2.1 Use Record for Immutable Data
+**Recommendation**: When defining DTOs or value objects, prioritize using `record` to gain built-in equality comparison and immutability.
+```csharp
+public record UserDto(int Id, string Name, string Email);
+```
+
+### 2.2 Collection Expressions (C# 12+)
+**Recommendation**: Use the consistent `[]` syntax to initialize various collection types.
+```csharp
+int[] array = [1, 2, 3];
+List<string> names = ["Alice", "Bob"];
+Span<byte> buffer = [0x01, 0x02];
+```
+
+### 2.3 Raw String Literals (C# 11+)
+**Recommendation**: Avoid tedious escape characters when dealing with JSON, SQL, or multi-line text.
+```csharp
+string json = """
+{
+    "name": "Gemini",
+    "version": "1.4"
+}
+""";
+```
+
+---
+
+## 3. Logic and Expressions
+
+### 3.1 Pattern Matching
+**Recommendation**: Use `switch` expressions instead of traditional `switch` statements, and utilize property patterns.
+```csharp
+public decimal GetDiscount(Order order) => order switch
+{
+    { TotalAmount: > 1000 } => 0.1m,
+    { Items.Count: > 5 } => 0.05m,
+    _ => 0m
+};
+```
+
+### 3.2 Expression-bodied Members
+**Recommendation**: Use `=>` to shorten code for single-line methods or read-only properties.
+```csharp
+public override string ToString() => $"{FirstName} {LastName}";
+```
+
+---
+
+## 4. C# 14+ Forward-looking Patterns
+
+### 4.1 Field-backed Properties
+**Recommendation**: Use the `field` keyword in auto-properties that require simple logic.
+```csharp
+public string Nickname 
+{ 
+    get; 
+    set => field = value?.Trim() ?? "Guest"; 
+}
+```
+
+### 4.2 Extension Members
+**Recommendation**: Use `extension` blocks to add properties or static members to existing types, not just methods.
+```csharp
+public extension UserExtension for User
+{
+    public bool IsAdmin => this.Roles.Contains("Admin");
+}
+```
+
+---
+
+## 5. Security and Performance
+
+### 5.1 Readonly Members
+**Recommendation**: In `struct`s, if a method does not modify state, it should be marked as `readonly` to facilitate compiler optimizations.
+```csharp
+public readonly struct Point(double x, double y)
+{
+    public readonly double Distance => Math.Sqrt(x * x + y * y);
+}
+```
+
+### 5.2 Default Lambda Parameters
+**Recommendation**: Provide default values for Lambda expressions to increase flexibility.
+```csharp
+var greeter = (string name = "Guest") => $"Hello, {name}!";
+```
+
+---
+
+## 6. Null Safety
+
+### 6.1 Nullable Reference Types (C# 8.0+)
+**Recommendation**: Enable NRT at the project level, explicitly distinguish between "non-nullable" and "nullable" reference types, and shift null checks from runtime to compile time.
+```csharp
+public class UserProfile
+{
+    // Use required to ensure it's not Null after construction
+    public required string Username { get; set; } 
+
+    // Use ? to mark this field as allowing Null
+    public string? Bio { get; set; }             
+}
+```
+
+### 6.2 Improved Null Check Semantics
+**Recommendation**: Use `is not null` and the `??=` operator to make null handling logic cleaner and more readable.
+```csharp
+// Use is not null
+if (input is not null) { ... }
+
+// Use null-coalescing assignment operator
+_logger ??= NullLogger.Instance;
+```

package/skills/csharp-interface-generator/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: csharp-interface-generator
+version: "1.0.0"
+category: "Core"
+description: "專注於C#介面生成與檔案結構管理。"
+compatibility: "Supports C# 12/13 and .NET 10.0."
+---
+
+# C# Interface Generator Skill Specification
+
+## Perceive
+1. **Code Structure Recognition**: Parse C# Class content, identify properties, methods, and access modifiers.
+2. **Constraint Check**:
+   - Identify members with the `virtual` keyword.
+   - Identify non-`public` members.
+3. **Environment Awareness**: When the user specifies a target file, read the file content to check for the existence of an Interface with the same name.
+
+## Reason
+1. **Interface Generation Logic**:
+   - **Naming Convention**: The Interface name must be the Class name prefixed with `I`.
+   - **Property Filtering**:
+     - **Keep only** simple properties.
+     - **Strictly prohibit** properties containing the `virtual` modifier.
+     - **Getter Only**: All properties in the interface MUST only have a `get;` accessor. No `set;` or `init;` is allowed.
+     - Include only `public` members.
+   - **Formatting**: Ensure the generated Interface follows standard C# indentation and brace styles.
+2. **Smart Overwrite Strategy**:
+   - If the target file does not exist: Plan to create a new file with necessary namespaces.
+   - If the target file exists but has no Interface with the same name: Plan to append the new Interface to the end of the file.
+   - If the target file exists and already contains an Interface with the same name:
+     - Use regular expressions or block matching to find the start and end positions of the Interface.
+     - Plan to replace only that specific block, preserving other classes, interfaces, or using declarations in the file.
+
+## Act
+1. **Code Generation**: Output a C# Interface that complies with the Reason logic.
+2. **User Confirmation**:
+   - After generation, pause and ask the user: "In which file should this Interface be stored? (Please provide a relative path)".
+3. **Execution Write**:
+   - Based on the user's response, perform `read_file` (if the file exists) -> logical replacement -> `write_file`.
+   - Inform the user of the result (created, appended, or overwritten).