agent-workflow-kit-cli 1.3.0 → 1.3.2

package/dist/cli/commands/add.js

@@ -11,7 +11,7 @@ import { analyzeModule } from "../../core/analyzer.js";
 import { updateGitignore } from "./init.js";
 export async function runAdd(stack, options) {
     const targetStack = stack.toLowerCase();
-    const validStacks = ["spring-boot", "react-ts", "fastapi", "python-ai"];
+    const validStacks = ["spring-boot", "react-ts", "next-js", "nestjs", "express", "fastapi", "python-ai", "dotnet"];
     if (!validStacks.includes(targetStack)) {
         console.error(chalk.red(`Error: Invalid stack '${stack}'. Supported stacks are: ${validStacks.join(", ")}`));
         process.exit(1);

package/dist/cli/commands/doctor.js

@@ -96,10 +96,17 @@ npx agent-workflow-kit-cli doctor || exit 1
                 console.log(chalk.gray(`Running: ${cmd} ${args.join(" ")}`));
                 await execa(cmd, args, { cwd, stdio: "inherit" });
             }
-            else if (stack === "react-ts") {
+            else if (stack === "react-ts" ||
+                stack === "next-js" ||
+                stack === "nestjs" ||
+                stack === "express") {
                 console.log(chalk.gray("Running: npx tsc --noEmit"));
                 await execa("npx", ["tsc", "--noEmit"], { cwd, stdio: "inherit" });
             }
+            else if (stack === "dotnet") {
+                console.log(chalk.gray("Running: dotnet build"));
+                await execa("dotnet", ["build"], { cwd, stdio: "inherit" });
+            }
             console.log(chalk.green(`✔️ ${stack} validation passed!`));
         }
         catch (err) {

package/dist/cli/commands/init.js

@@ -30,7 +30,14 @@ function printSuccessAndNextSteps(options) {
 }
 export async function updateGitignore(targetDir, dryRun) {
     const gitignorePath = path.join(targetDir, ".gitignore");
-    const rulesToIgnore = [".cursorrules", ".copilot-instructions.md", ".clinerules"];
+    const rulesToIgnore = [
+        ".cursorrules",
+        ".copilot-instructions.md",
+        ".clinerules",
+        "AGENTS.md",
+        "GEMINI.md",
+        ".agents/"
+    ];
     if (dryRun) {
         console.log(chalk.gray(`[Dry Run] Would update .gitignore in ${targetDir} to exclude IDE rule files.`));
         return;
@@ -78,6 +85,87 @@ async function writeWorkspaceIdeRulesAndGitignore(cwd, options) {
     }
     await updateGitignore(cwd, options.dryRun);
 }
+async function writeDefaultWorkflow(cwd, options) {
+    const workflowsDir = path.join(cwd, ".agents", "workflows");
+    const workflowFile = path.join(workflowsDir, "pr-verification.json");
+    const sampleWorkflow = {
+        id: "pr-verification",
+        name: "Pull Request Verification & ADR Flow",
+        description: "Compiles project, validates architecture boundaries, creates ADR, and requests human sign-off.",
+        version: "1.0.0",
+        supportedArchitectures: ["layered", "clean-architecture", "feature-first"],
+        requiredRoles: ["developer"],
+        graph: {
+            nodes: [
+                {
+                    id: "build-and-lint",
+                    name: "Compile and Lint Check",
+                    type: "task",
+                    executor: "command",
+                    params: {
+                        command: "npm run build || mvn compile || python -m py_compile **/*.py"
+                    },
+                    mockOutput: {
+                        status: "success",
+                        duration: "3.5s"
+                    }
+                },
+                {
+                    id: "verify-architecture",
+                    name: "Verify Layer Boundaries",
+                    type: "task",
+                    executor: "command",
+                    params: {
+                        command: "npx agent-workflow-kit-cli profile"
+                    },
+                    mockOutput: {
+                        violationsFound: 0,
+                        status: "clean"
+                    }
+                },
+                {
+                    id: "create-adr",
+                    name: "Generate Architecture Decision Record",
+                    type: "task",
+                    executor: "adr-generate",
+                    params: {
+                        title: "Automated PR Validation Record",
+                        status: "proposed",
+                        context: "Auto-generated during pipeline test run.",
+                        decision: "All structural layers passed boundary checks successfully.",
+                        consequences: "Workspace rules integrity confirmed."
+                    },
+                    mockOutput: {
+                        adrId: "ADR-0001",
+                        status: "proposed"
+                    }
+                },
+                {
+                    id: "operator-approval",
+                    name: "Operator Sign-off Hook",
+                    type: "approval"
+                }
+            ],
+            edges: [
+                { sourceId: "build-and-lint", targetId: "verify-architecture" },
+                { sourceId: "verify-architecture", targetId: "create-adr" },
+                { sourceId: "create-adr", targetId: "operator-approval" }
+            ]
+        }
+    };
+    if (options.dryRun) {
+        console.log(chalk.gray(`[Dry Run] Would create default workflow under ${workflowFile}`));
+        return;
+    }
+    try {
+        await fs.mkdir(workflowsDir, { recursive: true });
+        await fs.writeFile(workflowFile, JSON.stringify(sampleWorkflow, null, 2), "utf8");
+        console.log(chalk.green("✔️ Created default workflow pack: .agents/workflows/pr-verification.json"));
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`Could not create default workflow: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
 export async function runInit(options) {
     const cwd = process.cwd();
     console.log(chalk.bold.cyan("\n🚀 Agent Workflow Kit - Initializing..."));
@@ -292,5 +380,7 @@ export async function runInit(options) {
     }
     // Write workspace-level IDE rules and update gitignore
     await writeWorkspaceIdeRulesAndGitignore(cwd, options);
+    // Write default sample workflow DAG
+    await writeDefaultWorkflow(cwd, options);
     printSuccessAndNextSteps(options);
 }

package/dist/cli/index.js

@@ -19,11 +19,11 @@ export function runCli() {
     program
         .name("agent-workflow-kit")
         .description("Generate AI coding workflows/rules/templates for Codex and Antigravity")
-        .version("1.3.0");
+        .version("1.3.2");
     program
         .command("init")
         .description("Initialize agent guidelines and skills for the repository")
-        .option("--stack <stack>", "Specify target stack: auto | spring-boot | react-ts | fastapi", "auto")
+        .option("--stack <stack>", "Specify target stack: auto | spring-boot | react-ts | next-js | nestjs | express | fastapi | dotnet", "auto")
         .option("--agent <agent>", "Specify target agent profile: both | codex | antigravity", "both")
         .option("--dry-run", "Output actions to console without writing any files", false)
         .action(async (options) => {

package/dist/core/analyzer.js

@@ -356,22 +356,36 @@ async function analyzeSpringBoot(dir) {
 async function analyzeReactTs(dir) {
     let packageManager = "npm";
     let runCommand = "npm run";
+    let executeCommand = "npx";
+    let lockFile = "package-lock.json";
     try {
         const hasYarnLock = await fs.stat(path.join(dir, "yarn.lock")).then((s) => s.isFile()).catch(() => false);
         const hasPnpmLock = await fs.stat(path.join(dir, "pnpm-lock.yaml")).then((s) => s.isFile()).catch(() => false);
+        const hasBunLockb = await fs.stat(path.join(dir, "bun.lockb")).then((s) => s.isFile()).catch(() => false);
+        const hasBunLock = await fs.stat(path.join(dir, "bun.lock")).then((s) => s.isFile()).catch(() => false);
         if (hasYarnLock) {
             packageManager = "yarn";
             runCommand = "yarn";
+            executeCommand = "yarn dlx";
+            lockFile = "yarn.lock";
         }
         else if (hasPnpmLock) {
             packageManager = "pnpm";
             runCommand = "pnpm";
+            executeCommand = "pnpm dlx";
+            lockFile = "pnpm-lock.yaml";
+        }
+        else if (hasBunLockb || hasBunLock) {
+            packageManager = "bun";
+            runCommand = "bun run";
+            executeCommand = "bunx";
+            lockFile = hasBunLockb ? "bun.lockb" : "bun.lock";
         }
     }
     catch {
         // Use default
     }
-    return { packageManager, runCommand };
+    return { packageManager, runCommand, executeCommand, lockFile };
 }
 /**
  * Analyzes FastAPI project details.
@@ -439,6 +453,42 @@ async function analyzePythonAi(dir) {
     }
     return { packageManager, runCommand, hasGpuLibraries, hasHardwareLibraries };
 }
+/**
+ * Analyzes Next.js project details.
+ */
+async function analyzeNextJs(dir) {
+    const ctx = await analyzeReactTs(dir);
+    return {
+        packageManager: ctx.packageManager,
+        runCommand: ctx.runCommand,
+        executeCommand: ctx.executeCommand,
+        lockFile: ctx.lockFile,
+    };
+}
+/**
+ * Analyzes NestJS project details.
+ */
+async function analyzeNestJs(dir) {
+    const ctx = await analyzeReactTs(dir);
+    return {
+        packageManager: ctx.packageManager,
+        runCommand: ctx.runCommand,
+        executeCommand: ctx.executeCommand,
+        lockFile: ctx.lockFile,
+    };
+}
+/**
+ * Analyzes Express.js project details.
+ */
+async function analyzeExpress(dir) {
+    const ctx = await analyzeReactTs(dir);
+    return {
+        packageManager: ctx.packageManager,
+        runCommand: ctx.runCommand,
+        executeCommand: ctx.executeCommand,
+        lockFile: ctx.lockFile,
+    };
+}
 /**
  * Entry point to analyze module configurations.
  */
@@ -451,12 +501,107 @@ export async function analyzeModule(dir, stacks) {
         else if (stack === "react-ts") {
             context["react-ts"] = await analyzeReactTs(dir);
         }
+        else if (stack === "next-js") {
+            context["next-js"] = await analyzeNextJs(dir);
+        }
+        else if (stack === "nestjs") {
+            context["nestjs"] = await analyzeNestJs(dir);
+        }
+        else if (stack === "express") {
+            context["express"] = await analyzeExpress(dir);
+        }
         else if (stack === "fastapi") {
             context["fastapi"] = await analyzeFastApi(dir);
         }
         else if (stack === "python-ai") {
             context["python-ai"] = await analyzePythonAi(dir);
         }
+        else if (stack === "dotnet") {
+            context["dotnet"] = await analyzeDotnet(dir);
+        }
     }
     return context;
 }
+/**
+ * Analyzes dotnet project details.
+ */
+async function analyzeDotnet(dir) {
+    let solutionName = path.basename(dir);
+    const projectNames = [];
+    const testProjects = [];
+    let dotnetVersion = "8.0";
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        // Find .sln file
+        const slnFile = entries.find(e => e.isFile() && e.name.endsWith(".sln"));
+        if (slnFile) {
+            solutionName = path.parse(slnFile.name).name;
+        }
+        // Find all .csproj files (recursively)
+        const csprojFiles = await findCsprojFiles(dir);
+        for (const file of csprojFiles) {
+            const projName = path.parse(file).name;
+            try {
+                const content = await fs.readFile(file, "utf8");
+                if (content.includes("Microsoft.NET.Test.Sdk") || projName.toLowerCase().includes("test")) {
+                    testProjects.push(projName);
+                }
+                else {
+                    projectNames.push(projName);
+                }
+                // Try to parse TargetFramework
+                const match = content.match(/<TargetFramework>net([\d\.]+)<\/TargetFramework>/);
+                if (match && match[1]) {
+                    dotnetVersion = match[1];
+                }
+            }
+            catch {
+                projectNames.push(projName);
+            }
+        }
+    }
+    catch {
+        // Keep defaults
+    }
+    return {
+        solutionName,
+        projectNames,
+        dotnetVersion,
+        testProjects,
+    };
+}
+async function findCsprojFiles(dir) {
+    const files = [];
+    async function traverse(currentDir) {
+        if (files.length >= 20)
+            return;
+        try {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.length >= 20)
+                    return;
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name.startsWith(".") ||
+                        entry.name === "node_modules" ||
+                        entry.name === "bin" ||
+                        entry.name === "obj" ||
+                        entry.name === "target" ||
+                        entry.name === "build" ||
+                        entry.name === "dist") {
+                        continue;
+                    }
+                    await traverse(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".csproj")) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    await traverse(dir);
+    return files;
+}

package/dist/core/awos/intelligence.js

@@ -141,23 +141,41 @@ export async function buildRepositoryContext(workspaceRoot) {
     }
     // Determine default architecture style based on stack
     let architecture = "layered";
-    if (mainStack === "spring-boot") {
+    if (mainStack === "spring-boot" || mainStack === "dotnet") {
         architecture = "clean-architecture";
     }
-    else if (mainStack === "react-ts") {
+    else if (mainStack === "react-ts" || mainStack === "next-js") {
         architecture = "feature-first";
     }
+    else if (mainStack === "nestjs") {
+        architecture = "module-driven";
+    }
+    else if (mainStack === "express") {
+        architecture = "layered";
+    }
     else if (mainStack === "fastapi") {
         architecture = "vertical-slice";
     }
     // Testing strategy defaults
     const frameworks = [];
-    if (mainStack === "react-ts")
+    if (mainStack === "react-ts") {
         frameworks.push("vitest", "testing-library");
-    else if (mainStack === "spring-boot")
+    }
+    else if (mainStack === "next-js") {
+        frameworks.push("jest", "playwright");
+    }
+    else if (mainStack === "nestjs" || mainStack === "express") {
+        frameworks.push("jest", "supertest");
+    }
+    else if (mainStack === "spring-boot") {
         frameworks.push("junit", "mockito");
-    else if (mainStack === "fastapi")
+    }
+    else if (mainStack === "fastapi") {
         frameworks.push("pytest");
+    }
+    else if (mainStack === "dotnet") {
+        frameworks.push("xunit", "moq");
+    }
     const testing = {
         frameworks,
         coverageGoal: 80,
@@ -167,12 +185,18 @@ export async function buildRepositoryContext(workspaceRoot) {
     if (mainStack === "spring-boot") {
         validationLibraries.push("jakarta.validation");
     }
-    else if (mainStack === "react-ts") {
+    else if (mainStack === "react-ts" || mainStack === "next-js" || mainStack === "express") {
         validationLibraries.push("zod");
     }
+    else if (mainStack === "nestjs") {
+        validationLibraries.push("class-validator");
+    }
     else if (mainStack === "fastapi") {
         validationLibraries.push("pydantic");
     }
+    else if (mainStack === "dotnet") {
+        validationLibraries.push("fluentvalidation");
+    }
     const registry = await loadAWOSPlugins(workspaceRoot);
     let context = {
         stack: mainStack,

package/dist/core/detector.js

@@ -38,16 +38,30 @@ async function detectProjectStackDirect(cwd) {
             }
         }
     }
-    // 2. Detect React + TypeScript (package.json containing react dependency)
+    // 2. Detect Node.js / JavaScript / TypeScript stacks (React, Next.js, NestJS, Express)
     try {
         const pkgPath = path.join(cwd, "package.json");
         const content = await fs.readFile(pkgPath, "utf8");
         const pkgJson = JSON.parse(content);
-        const hasReact = (pkgJson.dependencies && pkgJson.dependencies.react) ||
-            (pkgJson.devDependencies && pkgJson.devDependencies.react);
-        if (hasReact) {
+        const deps = pkgJson.dependencies || {};
+        const devDeps = pkgJson.devDependencies || {};
+        const hasReact = deps.react || devDeps.react;
+        const hasNext = deps.next || devDeps.next;
+        const hasNest = deps["@nestjs/core"] || devDeps["@nestjs/core"];
+        const hasExpress = deps.express || devDeps.express;
+        if (hasNext) {
+            stacks.push("next-js");
+        }
+        else if (hasReact) {
             stacks.push("react-ts");
         }
+        const hasNestConfig = await fs.stat(path.join(cwd, "nest-cli.json")).then((s) => s.isFile()).catch(() => false);
+        if (hasNest || hasNestConfig) {
+            stacks.push("nestjs");
+        }
+        else if (hasExpress) {
+            stacks.push("express");
+        }
     }
     catch {
         // Ignore
@@ -102,6 +116,20 @@ async function detectProjectStackDirect(cwd) {
             }
         }
     }
+    // 4. Detect .NET (files ending in .csproj or .sln, or global.json)
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        const hasDotnet = entries.some((entry) => entry.isFile() &&
+            (entry.name.endsWith(".csproj") ||
+                entry.name.endsWith(".sln") ||
+                entry.name === "global.json"));
+        if (hasDotnet) {
+            stacks.push("dotnet");
+        }
+    }
+    catch {
+        // Ignore
+    }
     return stacks;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-workflow-kit-cli",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "AI-Ready Repository Workflow Generator & Guideline Optimizer for Codex and Antigravity",
   "type": "module",
   "main": "./dist/index.js",

package/templates/dotnet/AGENTS.md.hbs

@@ -0,0 +1,53 @@
+## 🗺️ Hướng Dẫn Phát Triển .NET (C#)
+
+Dự án này là một ứng dụng .NET (C#), được tổ chức và cấu hình như sau:
+- **Tên Solution:** `{{solutionName}}`
+- **Phiên bản .NET:** `net{{dotnetVersion}}`
+- **Các dự án thành phần:** 
+  {{#each projectNames}}
+  - `{{this}}`
+  {{/each}}
+- **Các dự án kiểm thử (Test Projects):**
+  {{#each testProjects}}
+  - `{{this}}`
+  {{/each}}
+
+---
+
+### 🔄 Vòng Đời Phát Triển Tác Nhân (Agent Development Lifecycle)
+Tác nhân AI phải thực hiện tất cả các nhiệm vụ .NET theo quy trình 5 bước sau:
+1. **Thiết kế & Lập trình:** Triển khai các lớp nghiệp vụ tuân thủ cấu trúc Clean Architecture / Onion Architecture. Đặt Core Logic trong Application/Domain layer độc lập.
+2. **Kiểm thử Toàn diện:** Viết unit test cho các Service sử dụng xUnit và Moq.
+3. **Chất lượng Mã nguồn:** Chạy các lệnh kiểm tra lỗi cú pháp và kiểu dữ liệu:
+   - Chạy Build kiểm tra: `dotnet build`
+   - Chạy Kiểm thử: `dotnet test`
+4. **Quản lý Thư viện:** Thêm các gói NuGet mới qua lệnh: `dotnet add package [tên_gói]`.
+
+---
+
+### 🏗️ Kiến Trúc Hệ Thống Bản Mẫu (Template Blueprint)
+Vui lòng tham khảo các tài liệu quy tắc chi tiết dưới đây:
+- Quy ước coding style chuẩn C#, PascalCase, camelCase và tiền tố Interface: `@csharp-style.md`
+- Quy định đăng ký và sử dụng Dependency Injection (Transient, Scoped, Singleton): `@dependency-injection.md`
+- Phân định trách nhiệm API Controller và điều phối luồng xử lý: `@api-structure.md`
+- Cấu hình FluentValidation và middleware xử lý ngoại lệ tập trung: `@error-handling-validation.md`
+- Quy trình từng bước sinh mới API Controller, DTO, Request Validator: `@SKILL.md`
+
+---
+
+### 🏛️ Quy Tắc Phát Triển Nghiêm Ngặt
+
+#### 1. Kiến Trúc Sạch (Clean Architecture)
+Phân tách rõ ràng các tầng trách nhiệm:
+- **Domain:** Chứa Entities, Value Objects, Domain Logic. Tuyệt đối không phụ thuộc vào bất kỳ thư viện ngoài nào.
+- **Application:** Chứa Interfaces, DTOs, Use Cases (Services/Queries/Commands). Chỉ phụ thuộc vào Domain layer.
+- **Infrastructure:** Chứa Data Access (EF Core), External Services. Phụ thuộc vào Application layer.
+- **Presentation (API):** Chứa Controllers, Middlewares. Điểm khởi chạy của ứng dụng.
+
+#### 2. Đăng Ký Dependency Injection (DI)
+- Sử dụng constructor injection để tiêm các dịch vụ cần thiết qua các interface.
+- Tuyệt đối cấm sử dụng Service Locator pattern (ví dụ: giải quyết dependencies thủ công qua `IServiceProvider` trong runtime).
+
+#### 3. Kiểm Thử Dữ Liệu Tự Động Với FluentValidation
+- Toàn bộ dữ liệu đầu vào của API Request phải được kiểm duyệt tự động thông qua các class Validator thừa kế từ `AbstractValidator<T>` của thư viện FluentValidation.
+- Không viết code validate thủ công bằng các câu lệnh `if` rải rác trong Controller.

package/templates/dotnet/rules/api-structure.md

@@ -0,0 +1,43 @@
+# Cấu Trúc Lớp Presentation (API Controllers)
+
+Tài liệu này quy định cấu trúc và trách nhiệm của API Controllers trong tầng Presentation của ứng dụng .NET.
+
+---
+
+## 🏛️ Trách Nhiệm Của API Controller
+API Controller chịu trách nhiệm:
+1. Nhận yêu cầu HTTP (HTTP Requests) từ client.
+2. Ánh xạ các tham số URL, Query String, hoặc Request Body vào các DTO tương ứng.
+3. Chuyển giao các tham số đó sang tầng Application (Services/Queries/Commands).
+4. Nhận lại kết quả và phản hồi Client thông qua các mã trạng thái HTTP phù hợp (200 OK, 201 Created, 400 Bad Request, 404 Not Found, v.v.).
+
+---
+
+## 🚦 Quy Tắc Phát Triển
+- **Controller mỏng (Thin Controllers):** Controllers không chứa bất kỳ logic nghiệp vụ, tính toán thuật toán, hay truy vấn DB trực tiếp. 100% logic đó phải nằm dưới Application layer.
+- **Không tiêm DbContext vào Controller:** DbContext phải được che giấu dưới Infrastructure / Repository layer. Tầng Presentation tuyệt đối không gọi DbContext.
+- **Sử dụng DTO thay vì Entity trực tiếp:**
+  - Không nhận trực tiếp Domain Entities làm đầu vào của Controller.
+  - Không trả trực tiếp Domain Entities về cho Client để tránh lộ cấu trúc DB hoặc lỗi cyclic references. Luôn ánh xạ qua các lớp DTO (Data Transfer Objects).
+- **Cấu hình định tuyến Route rõ ràng:** Sử dụng attribute routing để khai báo rõ ràng phương thức HTTP và endpoint:
+  ```csharp
+  [ApiController]
+  [Route("api/v1/[controller]")]
+  public class CoursesController : ControllerBase
+  {
+      private readonly ICourseService _courseService;
+
+      public CoursesController(ICourseService courseService)
+      {
+          _courseService = courseService;
+      }
+
+      [HttpGet("{id}")]
+      public async Task<IActionResult> GetById(Guid id)
+      {
+          var course = await _courseService.GetByIdAsync(id);
+          if (course == null) return NotFound();
+          return Ok(course);
+      }
+  }
+  ```

package/templates/dotnet/rules/csharp-style.md

@@ -0,0 +1,33 @@
+# Quy Ước Viết Mã C# (C# Coding Style & Conventions)
+
+Tài liệu này đặc tả quy chuẩn coding style, đặt tên biến, tên lớp và cách tổ chức file mã nguồn trong dự án .NET.
+
+---
+
+## 🏷️ Quy Ước Đặt Tên (Naming Conventions)
+
+### Quy tắc đặt tên Lớp và Thành phần
+- **PascalCase:** Áp dụng cho Class, Struct, Record, Enum, Interface, Method, và Public Properties.
+  - *Ví dụ:* `UserService`, `GetActiveUsers()`, `CreatedDate`.
+- **Interface Prefix:** Tên Interface bắt buộc phải bắt đầu bằng chữ cái `I`.
+  - *Ví dụ:* `IUserService`, `IUserRepository`.
+- **camelCase:** Áp dụng cho tham số đầu vào của hàm (method arguments) và các biến cục bộ (local variables).
+  - *Ví dụ:* `userId`, `requestPayload`.
+- **Private Fields Prefix:** Các trường dữ liệu private trong Class phải viết bằng camelCase và bắt đầu bằng dấu gạch dưới `_`.
+  - *Ví dụ:* `private readonly IUserRepository _userRepository;`.
+
+---
+
+## 📦 Tổ Chức Mã Nguồn & Định Dạng
+- **Namespaces:** Đặt namespace phản ánh cấu trúc thư mục của dự án để đảm bảo tính dễ tìm kiếm.
+  - *Ví dụ:* `ProjectName.Application.Services`.
+- **File Scoped Namespaces:** Sử dụng cú pháp namespace phạm vi file (File-scoped namespace) của C# 10+ để giảm cấp thụt lề thụt dòng không cần thiết:
+  ```csharp
+  namespace ProjectName.Application.Services;
+
+  public class UserService : IUserService
+  {
+      // ...
+  }
+  ```
+- **Sắp xếp Usings:** Đặt các chỉ thị `using` hệ thống (`System.*`) lên trước, tiếp theo là các thư viện bên thứ ba, và cuối cùng là các dự án nội bộ.

package/templates/dotnet/rules/dependency-injection.md

@@ -0,0 +1,54 @@
+# Đăng Ký & Sử Dụng Dependency Injection (DI)
+
+Tài liệu này hướng dẫn cách cấu hình và tiêm phụ thuộc trong các ứng dụng .NET Core.
+
+---
+
+## 💉 Constructor Injection (Tiêm qua Hàm khởi tạo)
+- **Quy tắc bắt buộc:** Luôn luôn giải quyết các phụ thuộc của Class thông qua Constructor. Gán chúng vào các trường private readonly có tiền tố gạch dưới `_`.
+- Tuyệt đối không dùng Service Locator (không gọi `app.Services.GetService<T>()` hay tiêm `IServiceProvider` để lấy service động tại runtime).
+
+  * **Không hợp lệ (❌ Nghiêm cấm):**
+    ```csharp
+    public class OrderService
+    {
+        private readonly IServiceProvider _serviceProvider;
+        
+        public OrderService(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
+        public void Process()
+        {
+            var repo = _serviceProvider.GetService<IOrderRepository>();
+            // ...
+        }
+    }
+    ```
+  * **Hợp lệ (✔️ Khuyến khích):**
+    ```csharp
+    public class OrderService : IOrderService
+    {
+        private readonly IOrderRepository _orderRepository;
+
+        public OrderService(IOrderRepository orderRepository)
+        {
+            _orderRepository = orderRepository;
+        }
+
+        public void Process()
+        {
+            var orders = _orderRepository.GetAll();
+            // ...
+        }
+    }
+    ```
+
+---
+
+## ⚙️ Đăng Ký Vòng Đời Dịch Vụ (Service Lifetimes)
+Lựa chọn đúng vòng đời khi đăng ký dịch vụ trong `Program.cs`:
+1. **Transient (`AddTransient<I, T>()`):** Tạo mới mỗi khi được yêu cầu. Dành cho các dịch vụ nhẹ, không lưu trạng thái (Stateless Services).
+2. **Scoped (`AddScoped<I, T>()`):** Tạo mới một lần cho mỗi HTTP Request. Thích hợp cho Repository, Database Context (`DbContext`), và các dịch vụ nghiệp vụ.
+3. **Singleton (`AddSingleton<I, T>()`):** Tạo một lần duy nhất cho toàn bộ vòng đời ứng dụng. Dành cho caching in-memory, cấu hình hệ thống, helper dùng chung.