dflow-sdd-ddd 0.3.0 → 0.5.0

package/lib/init.js

@@ -8,6 +8,21 @@ const pkg = require('../package.json');
 const MIN_NODE_VERSION = '22.0.0';
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 const TEMPLATE_ROOT = path.join(PACKAGE_ROOT, 'templates');
+const COMMAND_REGISTRY_START = '<!-- dflow-command-registry:start -->';
+const COMMAND_REGISTRY_END = '<!-- dflow-command-registry:end -->';
+const EXPECTED_COMMAND_IDS = [
+  'new-feature',
+  'modify-existing',
+  'bug-fix',
+  'new-phase',
+  'finish-feature',
+  'verify',
+  'pr-review',
+  'report-dflow-feedback',
+  'status',
+  'next',
+  'cancel'
+];
 
 const PROSE_LANGUAGE_PATTERN =
   /^[A-Za-z]{2,3}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?(?:-(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
@@ -91,11 +106,6 @@ const AI_AGENT_OPTIONS = [
     label: 'CLAUDE.md - Claude Code',
     aliases: ['claude', 'claude.md']
   },
-  {
-    key: 'gemini',
-    label: 'GEMINI.md - Gemini CLI',
-    aliases: ['gemini', 'gemini.md']
-  },
   {
     key: 'copilot',
     label: '.github/copilot-instructions.md - GitHub Copilot',
@@ -251,7 +261,8 @@ async function runConfigureAgents(options = {}) {
 
     const plan = await buildConfigureAgentsPlan(cwd, {
       ...projectContext,
-      aiAgents
+      aiAgents,
+      commandAdapters: Boolean(options.commandAdapters)
     });
 
     renderPreview(stdout, plan, []);
@@ -268,7 +279,7 @@ async function runConfigureAgents(options = {}) {
     result.warnings.push(...collectUnresolvedPlaceholderWarnings(plan, result.created));
 
     printResultReport(stdout, result, plan.deferred);
-    printConfigureAgentsNextSteps(stdout);
+    printConfigureAgentsNextSteps(stdout, Boolean(options.commandAdapters));
     return 0;
   } catch (error) {
     if (rl) {
@@ -383,7 +394,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 +432,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
   };
 }
 
@@ -963,8 +1010,14 @@ async function buildConfigureAgentsPlan(cwd, answers) {
     content
   });
 
+  const commandRegistry = answers.commandAdapters ? parseDflowCommandRegistry(content) : [];
+
   for (const agent of answers.aiAgents) {
-    await addAiAgentShim(cwd, items, agent, substitution);
+    await addAiAgentShim(cwd, items, agent, substitution, { commandRegistry });
+  }
+
+  if (answers.commandAdapters) {
+    addCommandAdapterItems(items, answers.aiAgents, commandRegistry);
   }
 
   await finalizePlanItems(cwd, items);
@@ -981,7 +1034,8 @@ async function buildConfigureAgentsPlan(cwd, answers) {
 async function finalizePlanItems(cwd, items) {
   for (const item of items) {
     const absolute = path.join(cwd, item.relativePath);
-    item.action = (await pathExists(absolute)) ? 'skip' : 'create';
+    const targetExists = await pathExists(absolute);
+    item.action = targetExists ? (item.overwrite ? 'update' : 'skip') : 'create';
     if (item.action === 'skip') {
       item.notes = item.notes ? `${item.notes}, already exists` : 'already exists';
     }
@@ -989,15 +1043,23 @@ async function finalizePlanItems(cwd, items) {
   }
 }
 
-async function addAiAgentShim(cwd, items, agent, substitution) {
+async function addAiAgentShim(cwd, items, agent, substitution, options = {}) {
   const target = getAiAgentTarget(agent);
   const targetPath = path.join(cwd, target.relativePath);
   const targetExists = await pathExists(targetPath);
   const targetConfigured = targetExists && await fileReferencesAiAgentGuide(targetPath);
-  const relativePath = targetExists && !targetConfigured ? target.snippetPath : target.relativePath;
-  const content = substitutePlaceholders(buildAiAgentShim(target.relativePath), substitution);
+  const commandRegistry = options.commandRegistry || [];
+  const codexCommandAdapterSnippet = target.relativePath === 'AGENTS.md' && commandRegistry.length > 0 && targetExists;
+  const relativePath = codexCommandAdapterSnippet
+    ? (targetConfigured ? 'dflow/specs/shared/AGENTS-md-command-adapters-snippet.md' : target.snippetPath)
+    : (targetExists && !targetConfigured ? target.snippetPath : target.relativePath);
+  const content = substitutePlaceholders(buildAiAgentShim(target.relativePath, options.commandRegistry), substitution);
   let notes = 'selected, tool-specific shim';
-  if (targetConfigured) {
+  if (codexCommandAdapterSnippet && targetConfigured) {
+    notes = `selected, ${target.relativePath} already points to AI-AGENT-GUIDE.md; merge this command trigger snippet manually`;
+  } else if (codexCommandAdapterSnippet) {
+    notes = `selected, ${target.relativePath} already exists; merge this command trigger snippet manually`;
+  } else if (targetConfigured) {
     notes = `selected, ${target.relativePath} already points to AI-AGENT-GUIDE.md`;
   } else if (targetExists) {
     notes = `selected, ${target.relativePath} already exists; merge this snippet manually`;
@@ -1007,7 +1069,8 @@ async function addAiAgentShim(cwd, items, agent, substitution) {
     relativePath,
     source: `generated:${agent}-shim`,
     notes,
-    content
+    content,
+    overwrite: codexCommandAdapterSnippet
   });
 }
 
@@ -1031,10 +1094,6 @@ function getAiAgentTarget(agent) {
       relativePath: 'CLAUDE.md',
       snippetPath: 'dflow/specs/shared/CLAUDE-md-snippet.md'
     },
-    gemini: {
-      relativePath: 'GEMINI.md',
-      snippetPath: 'dflow/specs/shared/GEMINI-md-snippet.md'
-    },
     copilot: {
       relativePath: '.github/copilot-instructions.md',
       snippetPath: 'dflow/specs/shared/copilot-instructions-snippet.md'
@@ -1044,12 +1103,16 @@ function getAiAgentTarget(agent) {
   return targets[agent];
 }
 
-function buildAiAgentShim(targetPath) {
+function buildAiAgentShim(targetPath, commandRegistry = []) {
   const title = targetPath === '.github/copilot-instructions.md'
     ? 'GitHub Copilot Repository Instructions'
     : `${targetPath} - Dflow Project Instructions`;
 
-  const importHint = targetPath === 'CLAUDE.md' || targetPath === 'GEMINI.md'
+  const commandTriggerHint = targetPath === 'AGENTS.md' && commandRegistry.length > 0
+    ? buildCodexCommandTriggerSection(commandRegistry)
+    : '';
+
+  const importHint = targetPath === 'CLAUDE.md'
     ? '\nIf your tool supports Markdown imports, the canonical guide is imported below:\n\n@dflow/specs/shared/AI-AGENT-GUIDE.md\n'
     : '';
 
@@ -1063,10 +1126,195 @@ Before planning or editing code, read and follow:
 
 Keep tool-specific instruction files small. The Dflow guide above is the
 single source of truth for project workflow rules, slash-command behavior,
-spec locations, and SDD/DDD constraints.${importHint}
+spec locations, and SDD/DDD constraints.${commandTriggerHint}${importHint}
 `;
 }
 
+function addCommandAdapterItems(items, aiAgents, commandRegistry) {
+  if (aiAgents.includes('claude')) {
+    for (const command of commandRegistry) {
+      items.push({
+        relativePath: `.claude/commands/dflow/dflow-${command.id}.md`,
+        source: 'generated:claude-command-adapter',
+        notes: 'command adapter, derived from dflow command registry',
+        content: buildThinCommandWrapper(command),
+        overwrite: true
+      });
+    }
+  }
+
+  if (aiAgents.includes('copilot')) {
+    for (const command of commandRegistry) {
+      items.push({
+        relativePath: `.github/prompts/dflow-${command.id}.prompt.md`,
+        source: 'generated:copilot-command-adapter',
+        notes: 'command adapter, derived from dflow command registry',
+        content: buildThinCommandWrapper(command),
+        overwrite: true
+      });
+    }
+  }
+}
+
+function buildCodexCommandTriggerSection(commandRegistry) {
+  const triggers = commandRegistry
+    .map((command) => {
+      const commandKind = command.scope === 'control' ? 'command' : 'workflow';
+      return `- \`${command.label}\` as text, or "Run the Dflow ${command.label} ${commandKind}."`;
+    })
+    .join('\n');
+
+  return `
+
+## Dflow Text Triggers
+
+Codex does not install Dflow command files. When the developer asks for a
+canonical Dflow command, treat it as a text trigger, read the canonical guide,
+and execute the matching workflow or control command.
+
+Recognized canonical triggers:
+
+${triggers}
+`;
+}
+
+function buildThinCommandWrapper(command) {
+  const argHint = command.argHint === '-'
+    ? 'Argument hint: none.'
+    : `Argument hint: ${command.argHint}.`;
+
+  return `# /dflow-${command.id}
+
+Execute the canonical \`${command.label}\` Dflow workflow or control command.
+
+Definition: \`dflow/specs/shared/AI-AGENT-GUIDE.md\`
+
+${argHint}
+`;
+}
+
+function parseDflowCommandRegistry(content) {
+  const start = content.indexOf(COMMAND_REGISTRY_START);
+  const end = content.indexOf(COMMAND_REGISTRY_END);
+
+  if (start === -1 || end === -1 || end <= start) {
+    throw new InitError('Internal error: dflow command registry markers not found in packaged AI-AGENT-GUIDE.md.');
+  }
+
+  const registryContent = content.slice(start + COMMAND_REGISTRY_START.length, end);
+  const tableLines = registryContent
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('|') && line.endsWith('|'));
+
+  if (tableLines.length < 3) {
+    throw new InitError('Internal error: dflow command registry table is empty.');
+  }
+
+  const header = parseMarkdownTableRow(tableLines[0]).map((cell) => cell.toLowerCase());
+  const expectedHeader = ['id', 'label', 'description', 'arg-hint', 'scope'];
+  if (header.length !== expectedHeader.length || !expectedHeader.every((cell, index) => header[index] === cell)) {
+    throw new InitError('Internal error: dflow command registry header must be: id, label, description, arg-hint, scope.');
+  }
+
+  const delimiter = parseMarkdownTableRow(tableLines[1]);
+  if (delimiter.length !== expectedHeader.length || !delimiter.every((cell) => /^:?-{3,}:?$/.test(cell))) {
+    throw new InitError('Internal error: dflow command registry delimiter row is invalid.');
+  }
+
+  const commands = [];
+  const seen = new Set();
+
+  for (const line of tableLines.slice(2)) {
+    const cells = parseMarkdownTableRow(line);
+    if (cells.length !== expectedHeader.length) {
+      throw new InitError(`Internal error: invalid dflow command registry row: ${line}`);
+    }
+
+    const command = {
+      id: stripInlineCode(cells[0]),
+      label: stripInlineCode(cells[1]),
+      description: stripInlineCode(cells[2]),
+      argHint: stripInlineCode(cells[3]),
+      scope: stripInlineCode(cells[4])
+    };
+
+    validateDflowCommandRegistryRow(command, seen);
+    commands.push(command);
+  }
+
+  const actualIds = commands.map((command) => command.id);
+  const missingIds = EXPECTED_COMMAND_IDS.filter((id) => !actualIds.includes(id));
+  const extraIds = actualIds.filter((id) => !EXPECTED_COMMAND_IDS.includes(id));
+  if (missingIds.length > 0 || extraIds.length > 0 || commands.length !== EXPECTED_COMMAND_IDS.length) {
+    throw new InitError(
+      `Internal error: dflow command registry must contain exactly these command ids: ${EXPECTED_COMMAND_IDS.join(', ')}.`
+    );
+  }
+
+  return commands;
+}
+
+function parseMarkdownTableRow(line) {
+  const trimmed = line.trim();
+  const inner = trimmed.slice(1, -1);
+  const cells = [];
+  let current = '';
+
+  for (let index = 0; index < inner.length; index += 1) {
+    const char = inner[index];
+    const next = inner[index + 1];
+
+    if (char === '\\' && next === '|') {
+      current += '|';
+      index += 1;
+      continue;
+    }
+
+    if (char === '|') {
+      cells.push(current.trim());
+      current = '';
+      continue;
+    }
+
+    current += char;
+  }
+
+  cells.push(current.trim());
+  return cells;
+}
+
+function stripInlineCode(value) {
+  const trimmed = String(value || '').trim();
+  if (trimmed.startsWith('`') && trimmed.endsWith('`') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function validateDflowCommandRegistryRow(command, seen) {
+  if (!/^[a-z][a-z0-9-]*$/.test(command.id)) {
+    throw new InitError(`Internal error: invalid dflow command id: ${command.id}`);
+  }
+  if (seen.has(command.id)) {
+    throw new InitError(`Internal error: duplicate dflow command id: ${command.id}`);
+  }
+  seen.add(command.id);
+
+  if (command.label !== `/dflow:${command.id}`) {
+    throw new InitError(`Internal error: dflow command label must be /dflow:${command.id}.`);
+  }
+  if (!command.description) {
+    throw new InitError(`Internal error: dflow command ${command.id} is missing a description.`);
+  }
+  if (!command.argHint) {
+    throw new InitError(`Internal error: dflow command ${command.id} is missing an arg-hint.`);
+  }
+  if (!command.scope) {
+    throw new InitError(`Internal error: dflow command ${command.id} is missing a scope.`);
+  }
+}
+
 function buildDeferredItems(edition) {
   const deferred = [...DEFERRED_COMMON];
   if (edition === 'greenfield') {
@@ -1104,13 +1352,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 +1375,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 +1405,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 +1511,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;
 }
@@ -1271,6 +1645,7 @@ function renderPreview(stdout, plan, warnings) {
 async function writeFilePlan(cwd, plan) {
   const result = {
     created: [],
+    updated: [],
     skipped: [],
     warnings: []
   };
@@ -1280,6 +1655,13 @@ async function writeFilePlan(cwd, plan) {
 
     try {
       if (await pathExists(targetPath)) {
+        if (item.overwrite) {
+          await fs.mkdir(path.dirname(targetPath), { recursive: true });
+          await fs.writeFile(targetPath, item.content);
+          result.updated.push(item.relativePath);
+          continue;
+        }
+
         result.skipped.push(item.relativePath);
         result.warnings.push(`Skipped existing target: ${item.relativePath}`);
         if (item.relativePath === 'dflow/specs/shared/_conventions.md') {
@@ -1366,6 +1748,9 @@ function printResultReport(stdout, result, deferred) {
   stdout.write('\nCreated:\n');
   printList(stdout, result.created);
 
+  stdout.write('\nUpdated:\n');
+  printList(stdout, result.updated);
+
   stdout.write('\nSkipped:\n');
   printList(stdout, result.skipped);
 
@@ -1386,10 +1771,15 @@ 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.
 `);
 }
 
-function printConfigureAgentsNextSteps(stdout) {
+function printConfigureAgentsNextSteps(stdout, commandAdapters = false) {
+  const commandAdapterStep = commandAdapters
+    ? '- Command adapters use adapter-native names such as `/dflow-new-feature`; canonical `/dflow:*` names remain defined in dflow/specs/shared/AI-AGENT-GUIDE.md.\n'
+    : '';
+
   stdout.write(`
 Dflow AI agent configuration complete.
 
@@ -1397,6 +1787,7 @@ Recommended next steps:
 - Keep AI-agent-specific root files small.
 - Put durable workflow changes in dflow/specs/shared/AI-AGENT-GUIDE.md.
 - If a merge snippet was created, review it and merge the pointer into the existing tool instruction file.
+${commandAdapterStep}
 `);
 }
 

package/package.json

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