dflow-sdd-ddd 0.2.0 → 0.4.0

package/docs/using-with-github-copilot.md

@@ -0,0 +1,177 @@
+# 在 GitHub Copilot 中使用 Dflow
+
+> **繁體中文** | [English](using-with-github-copilot.en.md)
+
+當你的 AI 程式設計助理是 GitHub Copilot（IDE chat + inline completions）時，Dflow 的使用體驗 walk-through。閱讀約需 10 分鐘。
+
+本指南專注於 GitHub Copilot 的具體使用體驗。工具中立的評估流程請見
+[`docs/evaluating-dflow.md`](evaluating-dflow.md)。完整的 Get Started
+與功能列表請見 [`README.md`](../README.md)。
+
+## 本指南的適用對象
+
+你正在使用或評估以 GitHub Copilot 作為 AI 程式設計助理的 Dflow。
+本指南說明 `init` 之後 Copilot 看到了什麼、repository shim 的位置、
+如何從 IDE 呼叫 Dflow workflow，以及幾個值得了解的 Copilot 專屬使用模式
+與 permission 行為。
+
+## 前置條件
+
+- 在你的 IDE（VS Code、JetBrains 或 GitHub.dev）中已啟用 GitHub Copilot。
+- 已具備 Node.js / npm 環境（Dflow 透過 npm 發佈）。以
+  `npm install -g dflow-sdd-ddd` 全域安裝，或用 `npx dflow-sdd-ddd init`
+  走免安裝路徑，確保 repository shim 存在。
+- 已具備 Dflow canonical 指南的基本認識：`dflow/specs/shared/AI-AGENT-GUIDE.md`。
+
+## `init` 之後 GitHub Copilot 看到了什麼
+
+`init` 為 Copilot 在以下路徑寫入一個小型的工具專屬薄 shim：
+
+- `.github/copilot-instructions.md`（注意：位於 `.github/` 目錄內，非專案根目錄）
+
+生成的 shim 範例：
+
+```markdown
+# GitHub Copilot Repository Instructions
+
+This project uses Dflow for spec-first AI-assisted development.
+
+Before planning or editing code, read and follow:
+
+- `dflow/specs/shared/AI-AGENT-GUIDE.md`
+```
+
+重點說明：
+
+- Copilot shim 位於 `.github/copilot-instructions.md`（見 `lib/init.js` mapping）。
+- Copilot shim 不含 Markdown `@` import。它只透過路徑指向 canonical 指南，讀取
+  `dflow/specs/shared/AI-AGENT-GUIDE.md` 時需明確開啟該檔案。
+
+## 在 GitHub Copilot 中使用 Dflow Workflow 指令
+
+Copilot 是 IDE 優先的助理（chat panel + inline completions），不是 CLI 工具。
+請把 Dflow workflow 名稱當成普通的對話指示，而非 CLI slash command：
+
+- 在 Copilot Chat 中：「Run the Dflow /dflow:new-feature workflow」—— Copilot
+  應讀取 canonical 指南並繼續執行。
+- 在程式碼 comment 或 editor chat 中，以普通文字描述 workflow：
+  `Run the Dflow /dflow:new-feature workflow.`
+
+可用的 workflow 入口：
+
+| 指令 | 適用情境 |
+|---|---|
+| `/dflow:new-feature` | 需要新增一個使用者可見的功能或業務行為。 |
+| `/dflow:modify-existing` | 需要修改現有行為。 |
+| `/dflow:bug-fix` | 可以用預期行為 vs 實際行為描述的缺陷。 |
+| `/dflow:new-phase` | 進行中的 feature 需要另一個實作 slice。 |
+| `/dflow:finish-feature` | 實作完成後需要進行漂移（drift）收尾。 |
+| `/dflow:verify` | 需要對 spec、領域文件、實作與測試進行一致性檢查。 |
+| `/dflow:pr-review` | 變更已準備好進行 SDD/DDD review。 |
+| `/dflow:report-dflow-feedback` | 你發現了 Dflow 的問題或改進點，想要一份清理過的上游回饋草稿。 |
+
+### 對話範例
+
+典型的 Copilot Chat workflow 如下：
+
+```text
+You: I'd like to use the /dflow:new-feature workflow. We need to add the
+     ability for users to export their data as CSV.
+
+Copilot: I'll help you structure this as a new feature. Let me start by
+         reviewing the AI-AGENT-GUIDE to understand the spec format.
+
+         Before drafting the feature spec, I need to understand the scope:
+
+         1. Should the CSV include all user data fields or a selected subset?
+         2. Which user roles should be able to trigger the export?
+         3. Are there any compliance or performance constraints I should know?
+
+You: All fields, only admin users, and exports should complete within 30 seconds
+     for datasets up to 1 million rows.
+
+Copilot: Got it. I'll create the feature spec at dflow/specs/features/active/
+         with these constraints. Let me also outline the implementation phases...
+```
+
+### 既有的 Repository 指示
+
+如果你的專案中已有 `.github/copilot-instructions.md`，`init` 不會覆蓋它。
+它改為在 `dflow/specs/shared/` 下寫入 merge snippet，讓你手動審閱後貼入
+既有檔案。這樣可以避免破壞你已有的自訂 Copilot 指示。
+
+到 `dflow/specs/shared/COPILOT-INSTRUCTIONS-MERGE-SNIPPET.md` 找到 merge
+snippet，再把相關段落貼入你現有的 `.github/copilot-instructions.md`。
+
+### Slash Command Passthrough 說明
+
+Copilot 是否會直通（passthrough）原始的 `/dflow:*` slash command，取決於
+IDE 整合方式與 Copilot 版本。若 Copilot 無法識別以 slash 為前綴的 workflow
+名稱，以普通文字重新送出請求：
+
+```text
+You: Instead of /dflow:new-feature, try: "Please help me start a new Dflow
+     feature workflow. Read dflow/specs/shared/AI-AGENT-GUIDE.md first."
+```
+
+## 與其他 AI 工具的差異
+
+canonical 指南（`dflow/specs/shared/AI-AGENT-GUIDE.md`）在各工具之間是相同的。
+只有根目錄層的 shim 有所不同：
+
+| 工具 | 產生的 shim | 載入 canonical 指南的方式 |
+|---|---|---|
+| GitHub Copilot | `.github/copilot-instructions.md` | 直接讀取 repository 指示 |
+| Claude Code | `CLAUDE.md` | `@dflow/specs/shared/AI-AGENT-GUIDE.md` Markdown import |
+| Gemini CLI | `GEMINI.md` | `@dflow/specs/shared/AI-AGENT-GUIDE.md` Markdown import |
+| Codex / Copilot coding agent | `AGENTS.md` | 啟動時直接讀取檔案內容 |
+
+- Shim 路徑：Copilot 使用 `.github/copilot-instructions.md`（不是 `AGENTS.md`
+  或 `CLAUDE.md`）。
+- Markdown import：Copilot shim 不含 `@dflow/specs/shared/AI-AGENT-GUIDE.md`
+  import。這點與 Claude Code / Gemini CLI 的 shim 透過 `@` import inline 嵌入不同。
+- 工具模型：Copilot 是 IDE-based（chat panel + inline completions）；
+  Codex / Claude Code 是 CLI-based agent。Copilot 透過編輯器 UI 互動，而非
+  command-line session。
+- Workflow 呼叫：使用 CLI agent 時可對 agent process 輸入 `/dflow:*`；使用
+  Copilot 時，建議在 Copilot Chat 或 editor comment 中使用普通文字描述。
+- Permission 模型：Copilot 依賴 IDE 的 permission 與 extension sandbox。它可能
+  受 editor-level approvals 管理；CLI 工具通常有明確的 sandbox flags 與獨立的
+  permission gates。
+
+## 常見模式與注意事項
+
+- 保持 `.github/copilot-instructions.md` 精簡。Canonical Dflow 指南
+  （`dflow/specs/shared/AI-AGENT-GUIDE.md`）才是 source of truth。
+- 若 Copilot 看起來只從 shim 文字工作，請明確要求它開啟或讀取
+  `dflow/specs/shared/AI-AGENT-GUIDE.md` 後再繼續。
+- Copilot 的 inline completions 可能在未走 Dflow workflow 的情況下直接建議程式碼；
+  需要 spec-driven 輸出時，請明確要求執行 workflow。
+- Copilot Chat context 不一定會在所有 IDE 版本中自動包含 `.github/` 目錄下的
+  repository 指示檔；行為因 Copilot / IDE 版本而異（見頁尾說明）。
+- 當 slash-prefixed forms 被 IDE 拒絕時，改用普通文字描述 workflow 名稱。
+
+## 下一步
+
+如果你還沒有執行 `init`：
+
+- 執行 `dflow init`（安裝後）或 `npx dflow-sdd-ddd init`，選擇 Copilot 目標
+  以建立 `.github/copilot-instructions.md`。參考
+  [評估者指南 Playbook](evaluating-dflow.md#30-分鐘評估-playbook) 在可拋棄的
+  範例專案中試用。
+
+如果你已執行 `init` 且想查看端到端的 workflow 範例：
+
+- 閱讀 [`dflow/specs/shared/AI-AGENT-GUIDE.md`](../sdd-ddd-greenfield-skill/scaffolding/AI-AGENT-GUIDE.md)
+  （或 brownfield 等效版本）後再開始 workflow。
+- 閱讀 [`tutorial/01-greenfield/`](../tutorial/01-greenfield/walkthrough-00-setup.md)，
+  其中有展示 Copilot chat flow 的對話範例。
+
+如果你想了解設計理念：
+
+- 閱讀[為什麼 AI 時代 DDD 更重要](why-ddd-for-ai.md)。
+
+---
+
+IDE 行為說明：Slash command passthrough 與 `.github/` 指示檔的自動包含行為，
+會因 Copilot / IDE 版本而異。依賴確切語意前請向 maintainer 確認。

package/docs/why-ddd-for-ai.en.md

@@ -0,0 +1,37 @@
+# Why DDD Matters More with AI
+
+> [繁體中文](why-ddd-for-ai.md) | **English**
+
+AI-assisted development changes the failure mode of software design. The team can produce more code faster, but unclear domain meaning is also amplified faster.
+
+When a project lacks shared language and explicit boundaries, small inconsistencies spread:
+
+- the same concept appears as `Order`, `Booking`, and `Transaction`
+- APIs encode different meanings for similar actions
+- business rules live in handlers, UI code, scripts, and tests
+- nobody can confidently say which behavior is authoritative
+
+An AI coding agent does not know the business domain by default. When the prompt is incomplete, it fills the missing parts with plausible logic. That logic may compile, pass superficial tests, and still be wrong. The most dangerous AI mistakes are often not syntax errors; they are reasonable-looking domain mistakes.
+
+DDD gives the spec a semantic backbone:
+
+| DDD idea | AI-era value |
+|---|---|
+| **Ubiquitous Language** | Keeps names and meanings stable across prompts, specs, code, and reviews. |
+| **Bounded Context** | Defines where a term or rule is valid, and prevents accidental meaning leaks. |
+| **Domain Model** | Gives behavior a clear owner instead of scattering rules across technical layers. |
+| **Domain Rules** | States what is correct, allowed, forbidden, and exceptional before code generation. |
+
+The important shift is where design lives. In older workflows, much of the real design could remain implicit in code. With AI, that is too late. The model needs constraints before it generates code.
+
+```text
+Without DDD:
+Prompt -> AI fills gaps -> Code -> Hidden domain drift
+
+With DDD:
+Domain meaning -> Structured spec -> AI implementation -> Reviewable code
+```
+
+Code still matters, but it is no longer the first place where meaning should be discovered. For AI collaboration, specs become the pre-generation contract, and DDD supplies the language, boundaries, and rules that make the contract precise.
+
+Dflow is built around that idea: spec first, domain meaning explicit, AI constrained before implementation, and drift checked before the work is considered done.

package/docs/why-ddd-for-ai.md

@@ -1,26 +1,28 @@
-# Why DDD Matters More with AI
+# 為什麼 AI 時代 DDD 更重要
 
-AI-assisted development changes the failure mode of software design. The team can produce more code faster, but unclear domain meaning is also amplified faster.
+> **繁體中文** | [English](why-ddd-for-ai.en.md)
 
-When a project lacks shared language and explicit boundaries, small inconsistencies spread:
+AI 輔助開發改變了軟體設計的失敗模式。團隊能更快產出更多程式碼，但不清晰的領域語義也會以同樣的速度擴散。
 
-- the same concept appears as `Order`, `Booking`, and `Transaction`
-- APIs encode different meanings for similar actions
-- business rules live in handlers, UI code, scripts, and tests
-- nobody can confidently say which behavior is authoritative
+當專案缺乏共同語言與明確邊界時，細小的不一致便會蔓延：
 
-An AI coding agent does not know the business domain by default. When the prompt is incomplete, it fills the missing parts with plausible logic. That logic may compile, pass superficial tests, and still be wrong. The most dangerous AI mistakes are often not syntax errors; they are reasonable-looking domain mistakes.
+- 同一個概念以 `Order`、`Booking`、`Transaction` 三種名稱出現
+- API 對相似動作賦予不同語義
+- 業務規則分散在 handler、UI 程式碼、腳本與測試之中
+- 沒有人能確定哪一個行為才是權威的
 
-DDD gives the spec a semantic backbone:
+AI 程式碼代理預設不了解業務領域。當 prompt 資訊不完整時，它會以看似合理的邏輯填補缺漏。這些邏輯可能通過編譯、通過表面測試，卻依然是錯的。AI 最危險的錯誤往往不是語法錯誤，而是外觀合理的領域錯誤。
 
-| DDD idea | AI-era value |
+DDD 為規格提供語義骨幹：
+
+| DDD 概念 | AI 時代的價值 |
 |---|---|
-| **Ubiquitous Language** | Keeps names and meanings stable across prompts, specs, code, and reviews. |
-| **Bounded Context** | Defines where a term or rule is valid, and prevents accidental meaning leaks. |
-| **Domain Model** | Gives behavior a clear owner instead of scattering rules across technical layers. |
-| **Domain Rules** | States what is correct, allowed, forbidden, and exceptional before code generation. |
+| **Ubiquitous Language（通用語言）** | 讓名稱與語義在 prompt、規格、程式碼與 review 之間保持穩定。 |
+| **Bounded Context** | 定義術語或規則的有效範圍，防止語義意外洩漏。 |
+| **領域模型（Domain Model）** | 讓行為有明確的所有者，而不是將規則分散在技術層之間。 |
+| **領域規則（Domain Rules）** | 在程式碼生成之前，先明確指出什麼是正確的、允許的、禁止的，以及例外情況。 |
 
-The important shift is where design lives. In older workflows, much of the real design could remain implicit in code. With AI, that is too late. The model needs constraints before it generates code.
+關鍵的轉變在於設計的位置。舊有的工作流程中，大量真正的設計可以隱含在程式碼裡。引入 AI 之後，這樣做已經太遲。模型需要在生成程式碼之前就取得約束條件。
 
 ```text
 Without DDD:
@@ -30,6 +32,6 @@ With DDD:
 Domain meaning -> Structured spec -> AI implementation -> Reviewable code
 ```
 
-Code still matters, but it is no longer the first place where meaning should be discovered. For AI collaboration, specs become the pre-generation contract, and DDD supplies the language, boundaries, and rules that make the contract precise.
+程式碼仍然重要，但不再是發現語義的第一現場。在 AI 協作模式下，規格成為生成前的契約，DDD 提供語言、邊界與規則，使契約具備精確性。
 
-Dflow is built around that idea: spec first, domain meaning explicit, AI constrained before implementation, and drift checked before the work is considered done.
+Dflow 正是圍繞這個理念建構：規格優先、領域語義顯式化、在實作前約束 AI，並在工作完成前驗證漂移（drift）。

package/lib/init.js

@@ -383,7 +383,16 @@ async function detectProjectSignals(cwd) {
       name.endsWith('.csproj') ||
       name === 'program.cs' ||
       name === 'startup.cs' ||
-      name === 'package.json'
+      name === 'package.json' ||
+      name === 'pom.xml' ||
+      name === 'build.gradle' ||
+      name === 'build.gradle.kts' ||
+      name === 'pyproject.toml' ||
+      name === 'requirements.txt' ||
+      name === 'go.mod' ||
+      name === 'cargo.toml' ||
+      name === 'composer.json' ||
+      name === 'gemfile'
     );
 
   const hasWebFormsFiles = Array.from(baseNames).some((name) =>
@@ -412,9 +421,36 @@ async function detectProjectSignals(cwd) {
     trackHint = 'brownfield';
   }
 
+  const stackHints = [];
+  if (coreSignal || webFormsSignal || csprojFiles.length > 0) {
+    stackHints.push('dotnet');
+  }
+  if (baseNames.has('pom.xml') || baseNames.has('build.gradle') || baseNames.has('build.gradle.kts')) {
+    stackHints.push('java');
+  }
+  if (baseNames.has('package.json')) {
+    stackHints.push('nodejs');
+  }
+  if (baseNames.has('pyproject.toml') || baseNames.has('requirements.txt')) {
+    stackHints.push('python');
+  }
+  if (baseNames.has('go.mod')) {
+    stackHints.push('go');
+  }
+  if (baseNames.has('cargo.toml')) {
+    stackHints.push('rust');
+  }
+  if (baseNames.has('composer.json')) {
+    stackHints.push('php');
+  }
+  if (baseNames.has('gemfile')) {
+    stackHints.push('ruby');
+  }
+
   return {
     hasSourceTree: hasSourceTree || relNames.has('src'),
-    trackHint
+    trackHint,
+    stackHints
   };
 }
 
@@ -1104,13 +1140,20 @@ async function readPackagedTemplate(edition, sourceRel) {
   }
 }
 
+const PLACEHOLDER_ALIASES = {
+  '{Framework version}': ['{ASP.NET Core version}', '{ASP.NET WebForms version}', '{.NET Framework version}'],
+  '{ORM / persistence}': ['{ORM / Data Access}'],
+  '{ORM version}': ['{EF Core version}'],
+  '{Mediator}': ['{MediatR version}']
+};
+
 function buildSubstitutionMap(cwd, answers) {
   const extracted = extractTechStackPlaceholders(answers.techStackSummary);
   const gitSelection = answers.optionalFiles.filter((key) => key === 'git-trunk' || key === 'git-flow');
   const gitStyle = gitSelection.length === 1 ? (gitSelection[0] === 'git-trunk' ? 'trunk' : 'gitflow') : null;
   const systemName = path.basename(cwd);
 
-  return new Map([
+  const map = new Map([
     ['{YYYY-MM-DD}', currentLocalDate()],
     ['{System Name}', systemName],
     ['{系統名稱}', systemName],
@@ -1120,15 +1163,26 @@ function buildSubstitutionMap(cwd, answers) {
     ['{migration-context}', answers.migrationContext],
     ['{prose-language}', answers.proseLanguage],
     ['{dflow-version}', pkg.version],
-    ['{ASP.NET Core version}', extracted.aspNetCoreVersion || '{ASP.NET Core version}'],
-    ['{EF Core version}', extracted.efCoreVersion || '{EF Core version}'],
-    ['{MediatR version}', extracted.mediatRVersion || '{MediatR version}'],
+    ['{Language}', extracted.language || '{Language}'],
+    ['{Framework}', extracted.framework || '{Framework}'],
+    ['{Framework version}', extracted.frameworkVersion || '{Framework version}'],
+    ['{ORM / persistence}', extracted.ormPersistence || '{ORM / persistence}'],
+    ['{ORM version}', extracted.ormVersion || '{ORM version}'],
+    ['{Mediator}', extracted.mediator || '{Mediator}'],
     ['{Test framework}', extracted.testFramework || '{Test framework}'],
-    ['{ASP.NET WebForms version}', extracted.webFormsVersion || '{ASP.NET WebForms version}'],
-    ['{.NET Framework version}', extracted.dotNetFrameworkVersion || '{.NET Framework version}'],
-    ['{ORM / Data Access}', extracted.ormDataAccess || '{ORM / Data Access}'],
     ['{gitflow|trunk}', gitStyle || '{gitflow|trunk}']
   ]);
+
+  for (const [canonical, aliases] of Object.entries(PLACEHOLDER_ALIASES)) {
+    const value = map.get(canonical);
+    if (value === undefined) continue;
+    const canonicalResolved = value !== canonical;
+    for (const alias of aliases) {
+      map.set(alias, canonicalResolved ? value : alias);
+    }
+  }
+
+  return map;
 }
 
 function substitutePlaceholders(content, substitution) {
@@ -1139,19 +1193,104 @@ function substitutePlaceholders(content, substitution) {
   return result;
 }
 
+const LANGUAGE_PATTERNS = [
+  /\bC#\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bC#\b/,
+  /\bTypeScript\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bTypeScript\b/i,
+  /\bJavaScript\b/i,
+  /\bKotlin\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bKotlin\b/i,
+  /\bJava\s*[0-9]+\b/i,
+  /\bJava\b/i,
+  /\bPython\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bPython\b/i,
+  /\bGolang\b/i,
+  /\bGo\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bPHP\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bPHP\b/i,
+  /\bRuby\b/i
+];
+
+const FRAMEWORK_VERSION_PATTERNS = [
+  /\bASP\.?NET\s+Core\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\b(?:ASP\.?NET\s+WebForms|WebForms)(?:\s+[0-9]+(?:\.[0-9]+)?)?\b/i,
+  /\b\.NET\s+Framework\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bSpring\s+Boot\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bSpring\s+MVC\b/i,
+  /\bNestJS\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bFastify\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bExpress(?:\.js)?\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bDjango\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bFastAPI\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bFlask\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bGin\s+v?[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bEcho\s+v?[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bLaravel\s*[0-9]+(?:\.[0-9]+)?\b/i
+];
+
+const FRAMEWORK_PATTERNS = [
+  /\bASP\.?NET\s+Core\b/i,
+  /\b(?:ASP\.?NET\s+WebForms|WebForms)\b/i,
+  /\b\.NET\s+Framework\b/i,
+  /\bSpring\s+Boot\b/i,
+  /\bSpring\s+MVC\b/i,
+  /\bNestJS\b/i,
+  /\bFastify\b/i,
+  /\bExpress(?:\.js)?\b/i,
+  /\bDjango\b/i,
+  /\bFastAPI\b/i,
+  /\bFlask\b/i,
+  /\bGin\b/i,
+  /\bEcho\b/i,
+  /\bLaravel\b/i
+];
+
+const ORM_VERSION_PATTERNS = [
+  /\b(?:EF\s+Core|Entity\s+Framework\s+Core)\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\b(?:EF6|Entity\s+Framework\s+6)\b/i,
+  /\bHibernate\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bSpring\s+Data\s+JPA\b/i,
+  /\bJPA\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bSQLAlchemy\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bPrisma\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bTypeORM\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bMikro-?ORM\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bGORM\s+v?[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bEloquent\s*[0-9]+(?:\.[0-9]+)?\b/i,
+  /\bDoctrine\s*[0-9]+(?:\.[0-9]+)?\b/i
+];
+
+const ORM_PERSISTENCE_PATTERNS = [
+  /\b(?:EF\s+Core|Entity\s+Framework\s+Core)\b/i,
+  /\b(?:EF6|Entity\s+Framework\s+6|Dapper|ADO\.NET)\b/i,
+  /\bHibernate\b/i,
+  /\bSpring\s+Data\s+JPA\b/i,
+  /\bJPA\b/i,
+  /\bSQLAlchemy\b/i,
+  /\bSQLModel\b/i,
+  /\bPrisma\b/i,
+  /\bTypeORM\b/i,
+  /\bMikro-?ORM\b/i,
+  /\bGORM\b/i,
+  /\bsqlx\b/i,
+  /\bEloquent\b/i,
+  /\bDoctrine\b/i
+];
+
 function extractTechStackPlaceholders(text) {
   if (!text || text.toLowerCase() === 'unknown') {
     return {};
   }
 
   return {
-    aspNetCoreVersion: firstMatch(text, /\bASP\.?NET\s+Core\s*[0-9]+(?:\.[0-9]+)?\b/i),
-    efCoreVersion: firstMatch(text, /\b(?:EF\s+Core|Entity\s+Framework\s+Core)\s*[0-9]+(?:\.[0-9]+)?\b/i),
-    mediatRVersion: firstMatch(text, /\bMediatR\s*[0-9]+(?:\.[0-9]+)?\b/i),
-    testFramework: extractTestFramework(text),
-    webFormsVersion: firstMatch(text, /\b(?:ASP\.?NET\s+WebForms|WebForms)(?:\s*[0-9]+(?:\.[0-9]+)?)?\b/i),
-    dotNetFrameworkVersion: firstMatch(text, /\b\.NET\s+Framework\s*[0-9]+(?:\.[0-9]+)?\b/i),
-    ormDataAccess: firstMatch(text, /\b(?:EF6|Entity\s+Framework\s+6|Dapper|ADO\.NET)\b/i)
+    language: firstPatternMatch(text, LANGUAGE_PATTERNS),
+    framework: firstPatternMatch(text, FRAMEWORK_PATTERNS),
+    frameworkVersion: firstPatternMatch(text, FRAMEWORK_VERSION_PATTERNS),
+    ormPersistence: firstPatternMatch(text, ORM_PERSISTENCE_PATTERNS),
+    ormVersion: firstPatternMatch(text, ORM_VERSION_PATTERNS),
+    mediator: firstMatch(text, /\bMediatR\s*[0-9]+(?:\.[0-9]+)?\b/i),
+    testFramework: extractTestFramework(text)
   };
 }
 
@@ -1160,15 +1299,38 @@ function firstMatch(text, regex) {
   return match ? match[0] : null;
 }
 
-function extractTestFramework(text) {
-  if (/\bxUnit\b/i.test(text)) {
-    return 'xUnit';
-  }
-  if (/\bNUnit\b/i.test(text)) {
-    return 'NUnit';
+function firstPatternMatch(text, patterns) {
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match) {
+      return match[0];
+    }
   }
-  if (/\bMSTest\b/i.test(text)) {
-    return 'MSTest';
+  return null;
+}
+
+function extractTestFramework(text) {
+  const patterns = [
+    [/\bxUnit\b/i, 'xUnit'],
+    [/\bNUnit\b/i, 'NUnit'],
+    [/\bMSTest\b/i, 'MSTest'],
+    [/\bJUnit\s*[0-9]+\b/i, null],
+    [/\bJUnit\b/i, 'JUnit'],
+    [/\bVitest\b/i, 'Vitest'],
+    [/\bJest\b/i, 'Jest'],
+    [/\bMocha\b/i, 'Mocha'],
+    [/\bpytest\b/i, 'pytest'],
+    [/\bunittest\b/i, 'unittest'],
+    [/\bgo\s+test\b/i, 'go test'],
+    [/\bPHPUnit\b/i, 'PHPUnit'],
+    [/\bPest\b/i, 'Pest']
+  ];
+
+  for (const [pattern, name] of patterns) {
+    const match = text.match(pattern);
+    if (match) {
+      return name || match[0];
+    }
   }
   return null;
 }
@@ -1386,6 +1548,7 @@ Recommended next steps:
 - For a new feature, use the Dflow new-feature workflow when it becomes available as a CLI command.
 - For brownfield changes, use the Dflow modify-existing workflow when it becomes available as a CLI command.
 - Before generating more specs, make sure dflow/specs/shared/_conventions.md has the correct Prose Language section.
+- For stack-specific examples (.NET, Java/Spring, Node/TypeScript, Python, Go, PHP/Laravel), see docs/examples-by-stack.md in the Dflow repo.
 `);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dflow-sdd-ddd",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Spec-first SDD/DDD workflow kit for AI-assisted development",
   "type": "commonjs",
   "bin": {

package/templates/brownfield/scaffolding/AI-AGENT-GUIDE.md

@@ -70,7 +70,8 @@ Signals:
   canonical English; compare against `TEMPLATE-LANGUAGE-GLOSSARY.md` if
   available.
 - References to a runtime `/dflow:init-project` slash command (V1
-  replaced it with the shell command `npx dflow-sdd-ddd init`).
+  replaced it with the Dflow CLI init command (`dflow init`, or
+  `npx dflow-sdd-ddd init` when using the no-install path)).
 - A root `CLAUDE.md`, `AGENTS.md`, or equivalent that holds the full
   Dflow workflow text instead of being a thin shim pointing to this
   file.