universal-dev-standards 5.1.0-beta.6 → 5.1.0

package/src/prompts/init.js

@@ -1,4 +1,6 @@
-import { select, checkbox, confirm as inquirerConfirm, Separator } from '@inquirer/prompts';
+import { select, checkbox, confirm as inquirerConfirm, Separator, input } from '@inquirer/prompts';
+import { existsSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
 import chalk from 'chalk';
 import os from 'os';
 import { t, setLanguage, detectLanguage } from '../i18n/messages.js';
@@ -1349,3 +1351,157 @@ export async function promptMethodology() {
 
   return methodology;
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Project Command Contract (uds.project.yaml) — XSPEC-029 Phase 3
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Detect project ecosystem and return suggested commands.
+ * @param {string} projectPath
+ * @returns {{ test: string, lint: string, build: string, security: string }}
+ */
+export function suggestCommands(projectPath) {
+  const p = (f) => join(projectPath, f);
+
+  if (existsSync(p('package.json')))
+    return { test: 'npm test', lint: 'npm run lint', build: 'npm run build', security: 'npm audit' };
+
+  if (existsSync(p('requirements.txt')) || existsSync(p('pyproject.toml')) || existsSync(p('setup.py')))
+    return { test: 'python -m pytest', lint: 'python -m ruff check .', build: 'python -m build', security: 'pip-audit' };
+
+  if (existsSync(p('go.mod')))
+    return { test: 'go test ./...', lint: 'go vet ./...', build: 'go build ./...', security: 'govulncheck ./...' };
+
+  if (existsSync(p('pom.xml')))
+    return { test: 'mvn test', lint: 'mvn checkstyle:check', build: 'mvn package', security: 'mvn dependency-check:check' };
+
+  if (existsSync(p('build.gradle')) || existsSync(p('build.gradle.kts')))
+    return { test: './gradlew test', lint: './gradlew checkstyleMain', build: './gradlew build', security: './gradlew dependencyCheckAnalyze' };
+
+  if (existsSync(p('Cargo.toml')))
+    return { test: 'cargo test', lint: 'cargo clippy', build: 'cargo build', security: 'cargo audit' };
+
+  if (existsSync(p('Gemfile')))
+    return { test: 'bundle exec rspec', lint: 'bundle exec rubocop', build: 'gem build *.gemspec', security: 'bundle audit' };
+
+  // C# — glob for .csproj / .sln
+  try {
+    const files = readdirSync(projectPath);
+    if (files.some(f => f.endsWith('.csproj') || f.endsWith('.sln')))
+      return { test: 'dotnet test', lint: 'dotnet format --verify-no-changes', build: 'dotnet build', security: 'dotnet list package --vulnerable' };
+  } catch {
+    // ignore read errors
+  }
+
+  // Unknown ecosystem — return empty strings so user fills them in
+  return { test: '', lint: '', build: '', security: '' };
+}
+
+/**
+ * Generate uds.project.yaml content from a commands map.
+ * @param {{ test?: string, lint?: string, build?: string, security?: string }} commands
+ * @returns {string}
+ */
+export function generateProjectConfigYaml(commands) {
+  const lines = ['version: "1"', '', 'commands:'];
+  for (const [intent, cmd] of Object.entries(commands)) {
+    if (cmd && cmd.trim()) {
+      lines.push(`  ${intent}: ${cmd.trim()}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Wraps promptProjectCommandContract with an initial confirm prompt.
+ * Used as the optional Step 13 in the init flow so the whole step can be
+ * mocked in tests as a single unit.
+ *
+ * @param {string} projectPath - Absolute project root path
+ * @returns {Promise<void>}
+ */
+export async function promptProjectContractStep(projectPath) {
+  try {
+    const wantContract = await inquirerConfirm({
+      message: 'Create uds.project.yaml (project command contract)?',
+      default: true
+    });
+    if (wantContract) {
+      await promptProjectCommandContract(projectPath);
+    }
+    // If false — silently skip (caller can show a hint message)
+  } catch {
+    // Ctrl+C or any error — treat as skip
+  }
+}
+
+/**
+ * Interactive wizard that guides the user through creating uds.project.yaml.
+ * Detects the project ecosystem and pre-fills defaults.
+ *
+ * @param {string} projectPath - Absolute project root path
+ * @returns {Promise<boolean>} true if the file was written, false if skipped
+ */
+export async function promptProjectCommandContract(projectPath) {
+  const contractPath = join(projectPath, 'uds.project.yaml');
+
+  // If already exists, ask whether to overwrite
+  if (existsSync(contractPath)) {
+    console.log();
+    console.log(chalk.yellow('  uds.project.yaml already exists.'));
+
+    const overwrite = await inquirerConfirm({
+      message: 'Overwrite existing uds.project.yaml?',
+      default: false
+    });
+
+    if (!overwrite) {
+      console.log(chalk.gray('  Skipped — keeping existing uds.project.yaml'));
+      return false;
+    }
+  }
+
+  const suggestions = suggestCommands(projectPath);
+  const hasAnySuggestion = Object.values(suggestions).some(v => v);
+
+  console.log();
+  console.log(chalk.bold('📋 Project Command Contract (uds.project.yaml)'));
+  console.log(chalk.gray('  Tell UDS how to run standard commands in this project (language-agnostic).'));
+  console.log(chalk.gray('  Press Enter to accept a suggestion, or type your own. Leave blank to skip.'));
+  console.log();
+
+  if (hasAnySuggestion) {
+    console.log(chalk.gray('  Detected suggestions:'));
+    for (const [intent, cmd] of Object.entries(suggestions)) {
+      if (cmd) console.log(chalk.gray(`    ${intent}: ${cmd}`));
+    }
+    console.log();
+  }
+
+  const intents = ['test', 'lint', 'build', 'security'];
+  const commands = {};
+
+  for (const intent of intents) {
+    const defaultVal = suggestions[intent] || '';
+    const answer = await input({
+      message: `  ${intent} command${defaultVal ? ` (default: ${defaultVal})` : ' (optional)'}:`,
+      default: defaultVal
+    });
+    commands[intent] = answer.trim();
+  }
+
+  const hasAnyCommand = Object.values(commands).some(v => v);
+  if (!hasAnyCommand) {
+    console.log(chalk.gray('  No commands entered — uds.project.yaml not created.'));
+    return false;
+  }
+
+  const yaml = generateProjectConfigYaml(commands);
+  writeFileSync(contractPath, yaml, 'utf-8');
+
+  console.log();
+  console.log(chalk.green('  ✔ uds.project.yaml created'));
+  console.log(chalk.gray(`    Path: ${contractPath}`));
+  return true;
+}

package/src/reconciler/actual-state-scanner.js

@@ -340,6 +340,30 @@ function scanHook(state, projectPath) {
   } catch {
     // Ignore read errors
   }
+
+  // Also scan native .git/hooks/pre-commit (installed by uds init for non-Node projects)
+  const nativeHookPath = join(projectPath, '.git', 'hooks', 'pre-commit');
+  if (existsSync(nativeHookPath)) {
+    try {
+      const content = readFileSync(nativeHookPath, 'utf-8');
+      const udsLines = content.split('\n').filter(line =>
+        line.includes('uds') || line.includes('UDS') || line.includes('.standards')
+      );
+
+      if (udsLines.length > 0) {
+        state.hook.set('.git/hooks/pre-commit', {
+          relativePath: '.git/hooks/pre-commit',
+          hash: computeFileHash(join(projectPath, '.git', 'hooks', 'pre-commit'))?.hash || null,
+          size: null,
+          category: 'hook',
+          sourcePath: null,
+          metadata: { udsLines, scanned: true, type: 'native' }
+        });
+      }
+    } catch {
+      // Ignore read errors
+    }
+  }
 }
 
 /**

package/src/uninstallers/hook-uninstaller.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { join } from 'path';
 
 /**
@@ -39,5 +39,36 @@ export function uninstallHook(projectPath, options = {}) {
     result.errors.push(`.husky/pre-commit — ${error.message}`);
   }
 
+  // Also handle native .git/hooks/pre-commit (installed by uds init for non-Node projects)
+  const nativeHookPath = join(projectPath, '.git', 'hooks', 'pre-commit');
+  if (existsSync(nativeHookPath)) {
+    try {
+      const content = readFileSync(nativeHookPath, 'utf-8');
+      const udsPattern = /uds\s+check|checkin-standards|UDS pre-commit hook/;
+
+      if (!udsPattern.test(content)) {
+        result.skipped.push('.git/hooks/pre-commit (no UDS lines found)');
+      } else if (dryRun) {
+        result.removed.push('.git/hooks/pre-commit (UDS native hook)');
+      } else {
+        // Remove only UDS-related lines, keep other hook content
+        const lines = content.split('\n');
+        const filtered = lines.filter(line => !udsPattern.test(line));
+
+        // If only shebang remains, remove the file entirely; otherwise rewrite
+        const nonEmpty = filtered.filter(l => l.trim() && l.trim() !== '#!/bin/sh');
+        if (nonEmpty.length === 0) {
+          unlinkSync(nativeHookPath);
+          result.removed.push('.git/hooks/pre-commit (UDS native hook, file removed)');
+        } else {
+          writeFileSync(nativeHookPath, filtered.join('\n'), 'utf-8');
+          result.removed.push('.git/hooks/pre-commit (UDS lines removed)');
+        }
+      }
+    } catch (error) {
+      result.errors.push(`.git/hooks/pre-commit — ${error.message}`);
+    }
+  }
+
   return result;
 }

package/src/utils/detect-self-adoption.js

@@ -0,0 +1,173 @@
+/**
+ * UDS Self-Adoption Detection
+ *
+ * Detect whether the current working directory is the UDS source repo itself.
+ * When detected, adoption-oriented CLI commands (update / check / init) MUST
+ * refuse to run — otherwise the CLI would overwrite source-of-truth
+ * `.standards/` with its own npm-bundled copy (DEC-044 / XSPEC-071).
+ *
+ * Detection uses three independent heuristics. ANY one being true is
+ * sufficient, but each is validated to reduce false positives:
+ *
+ *   1. `uds-manifest.json` in cwd whose `project === "Universal Development
+ *      Standards"` (strong signal — bundled manifests are adopter-named).
+ *   2. `cli/package.json` in cwd whose `name === "universal-dev-standards"`
+ *      (strong signal — only the UDS source repo ships this package).
+ *   3. `.uds-source-repo` marker file in cwd (explicit opt-in marker).
+ *
+ * The three signals are OR-combined: any single hit is enough. A consumer
+ * (adopter project) will hit none of them even if they installed UDS.
+ *
+ * Related:
+ *   - DEC-044: UDS Self-Adoption Bug
+ *   - XSPEC-071: UDS Self-Adoption Protection
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Indicator returned when detection matches, useful for diagnostics.
+ *
+ * @typedef {Object} SelfAdoptionResult
+ * @property {boolean} isSelfAdoption - True when cwd is UDS source repo
+ * @property {string[]} signals - Names of heuristics that matched
+ */
+
+/**
+ * Check whether `uds-manifest.json` at `cwd` identifies UDS source repo.
+ */
+function hasSourceManifest(cwd) {
+  const manifestPath = join(cwd, 'uds-manifest.json');
+  if (!existsSync(manifestPath)) return false;
+  try {
+    const content = readFileSync(manifestPath, 'utf8');
+    const manifest = JSON.parse(content);
+    return manifest?.project === 'Universal Development Standards';
+  } catch {
+    // Malformed JSON: fall back to "not matched" rather than throwing;
+    // the file alone is not strong enough proof without verified content.
+    return false;
+  }
+}
+
+/**
+ * Check whether `cli/package.json` at `cwd` identifies UDS source repo.
+ */
+function hasSourceCliPackage(cwd) {
+  const pkgPath = join(cwd, 'cli', 'package.json');
+  if (!existsSync(pkgPath)) return false;
+  try {
+    const content = readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(content);
+    return pkg?.name === 'universal-dev-standards';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check whether the explicit marker file exists.
+ */
+function hasSourceMarker(cwd) {
+  return existsSync(join(cwd, '.uds-source-repo'));
+}
+
+/**
+ * Detect UDS self-adoption situation.
+ *
+ * @param {string} [cwd=process.cwd()] - Directory to inspect
+ * @returns {boolean} True when cwd is (likely) the UDS source repo
+ */
+export function detectSelfAdoption(cwd = process.cwd()) {
+  return detectSelfAdoptionDetailed(cwd).isSelfAdoption;
+}
+
+/**
+ * Detect UDS self-adoption and return detailed signal breakdown.
+ *
+ * @param {string} [cwd=process.cwd()] - Directory to inspect
+ * @returns {SelfAdoptionResult} Detection outcome with matched signals
+ */
+export function detectSelfAdoptionDetailed(cwd = process.cwd()) {
+  const signals = [];
+  if (hasSourceManifest(cwd)) signals.push('uds-manifest.json');
+  if (hasSourceCliPackage(cwd)) signals.push('cli/package.json');
+  if (hasSourceMarker(cwd)) signals.push('.uds-source-repo');
+  return {
+    isSelfAdoption: signals.length > 0,
+    signals
+  };
+}
+
+/**
+ * Bilingual refuse message shown when self-adoption is detected and
+ * `--force` is not passed. Kept inline (not in i18n bundle) to avoid
+ * taking a translation dependency for a fail-safe error path.
+ *
+ * @param {string} commandName - e.g. 'update' / 'check' / 'init'
+ * @returns {string[]} Lines to print
+ */
+export function formatSelfAdoptionRefuseMessage(commandName) {
+  return [
+    `偵測到 UDS source repo。此指令（uds ${commandName}）僅供採用專案使用。`,
+    'Source repo 維護請使用 scripts/bump-version.sh 或 npm run docs:sync。',
+    '詳見 DEC-044。',
+    '',
+    `Detected UDS source repo. This command (uds ${commandName}) is for`,
+    'adopter projects only. For source-repo maintenance use',
+    'scripts/bump-version.sh or npm run docs:sync. See DEC-044.',
+    '',
+    'Override with --force if you know what you are doing',
+    '（若確定要執行可加上 --force 旗標繞過）.'
+  ];
+}
+
+/**
+ * Warning printed when `--force` bypasses the self-adoption guard.
+ *
+ * @param {string} commandName
+ * @returns {string[]} Lines to print
+ */
+export function formatSelfAdoptionForceWarning(commandName) {
+  return [
+    `警告：偵測到 UDS source repo，但 --force 已指定，繼續執行 uds ${commandName}。`,
+    `Warning: UDS source repo detected; --force was passed, continuing uds ${commandName}.`,
+    '若非預期操作，請立即 Ctrl+C 並改用 scripts/bump-version.sh。',
+    'If unintended, abort now (Ctrl+C) and use scripts/bump-version.sh.'
+  ];
+}
+
+/**
+ * Guard helper — prints refuse message and exits with non-zero code when
+ * cwd is the UDS source repo and `--force` was not supplied.
+ *
+ * Does nothing when not self-adoption, or when `--force` is set (in which
+ * case a warning is printed but execution proceeds).
+ *
+ * @param {string} commandName - CLI command being invoked (for message)
+ * @param {Object} [options] - Caller options; inspected for `force`
+ * @param {string} [cwd=process.cwd()]
+ * @returns {boolean} True if command should continue (caller keeps running)
+ */
+export function guardAgainstSelfAdoption(commandName, options = {}, cwd = process.cwd()) {
+  const { isSelfAdoption, signals } = detectSelfAdoptionDetailed(cwd);
+  if (!isSelfAdoption) return true;
+
+  const force = Boolean(options && options.force);
+  if (force) {
+    for (const line of formatSelfAdoptionForceWarning(commandName)) {
+      console.warn(line);
+    }
+    console.warn(`Matched signals: ${signals.join(', ')}`);
+    return true;
+  }
+
+  for (const line of formatSelfAdoptionRefuseMessage(commandName)) {
+    console.error(line);
+  }
+  console.error(`Matched signals: ${signals.join(', ')}`);
+  process.exit(1);
+  // Unreachable, but for tests that stub process.exit:
+  return false;
+}

package/src/utils/e2e-analyzer.js

@@ -192,6 +192,22 @@ export function analyzeExistingPatterns(e2eDir) {
 // REQ-4: E2E 測試骨架生成
 // ============================================================
 
+/**
+ * Detect the project ecosystem based on manifest files
+ * @param {string} [projectPath='.'] - Path to the project root
+ * @returns {'node'|'python'|'go'|'java'|'rust'|'ruby'}
+ */
+function detectEcosystem(projectPath = '.') {
+  const p = (f) => join(projectPath, f);
+  if (existsSync(p('package.json'))) return 'node';
+  if (existsSync(p('requirements.txt')) || existsSync(p('pyproject.toml'))) return 'python';
+  if (existsSync(p('go.mod'))) return 'go';
+  if (existsSync(p('pom.xml')) || existsSync(p('build.gradle'))) return 'java';
+  if (existsSync(p('Cargo.toml'))) return 'rust';
+  if (existsSync(p('Gemfile'))) return 'ruby';
+  return 'node'; // fallback
+}
+
 const SKELETON_TEMPLATES = {
   vitest: {
     header: (specId) => `/**
@@ -298,6 +314,65 @@ beforeEach(() => {
     // [TODO] Verify expected outcomes
     // cy.contains('expected text').should('be.visible');
   });
+`
+  },
+
+  // Python (pytest-playwright)
+  'pytest-playwright': {
+    header: (specId) => `# [Generated] E2E tests for ${specId}
+# [TODO] Fill in test implementations
+
+import pytest
+from playwright.sync_api import Page
+`,
+    setup: () => `
+# [TODO] Setup fixtures and test data
+`,
+    test: (scenario) => `
+# @${scenario.specId} @${scenario.ac}
+def test_${scenario.name.toLowerCase().replace(/\s+/g, '_')}(page: Page):
+    # Arrange
+    # [TODO] Setup test preconditions
+
+    # Act
+    # [TODO] Execute the user flow
+
+    # Assert
+    # [TODO] Verify expected outcomes
+`
+  },
+
+  // Go (chromedp)
+  chromedp: {
+    header: (specId) => `// [Generated] E2E tests for ${specId}
+// [TODO] Fill in test implementations
+
+package e2e_test
+
+import (
+\t"context"
+\t"testing"
+\t"github.com/chromedp/chromedp"
+)
+`,
+    setup: () => `
+// [TODO] Setup shared test context if needed
+`,
+    test: (scenario) => `
+// @${scenario.specId} @${scenario.ac}
+func Test${scenario.name.replace(/\s+/g, '')}(t *testing.T) {
+\tctx, cancel := chromedp.NewContext(context.Background())
+\tdefer cancel()
+
+\t// Arrange
+\t// [TODO] Setup test preconditions
+
+\t// Act
+\t// [TODO] Add chromedp tasks
+
+\t// Assert
+\t// [TODO] Verify expected outcomes
+}
 `
   }
 };
@@ -308,16 +383,24 @@ beforeEach(() => {
  * @param {{ framework: string }} options
  * @returns {string}
  */
-export function generateE2eSkeleton(scenarios, { framework = 'vitest' } = {}) {
-  const template = SKELETON_TEMPLATES[framework] || SKELETON_TEMPLATES.vitest;
+export function generateE2eSkeleton(scenarios, { framework = 'vitest', projectPath } = {}) {
+  // If no framework is explicitly specified (using default), detect ecosystem and adjust
+  const resolvedFramework = (() => {
+    if (framework !== 'vitest') return framework; // caller specified explicitly
+    const ecosystem = detectEcosystem(projectPath);
+    if (ecosystem === 'python') return 'pytest-playwright';
+    if (ecosystem === 'go') return 'chromedp';
+    return framework;
+  })();
+  const template = SKELETON_TEMPLATES[resolvedFramework] || SKELETON_TEMPLATES.vitest;
   const specId = scenarios[0]?.specId || 'SPEC-XXX';
 
   let output = template.header(specId);
   output += template.setup();
 
-  if (framework === 'vitest') {
+  if (resolvedFramework === 'vitest') {
     output += `\ndescribe('E2E: ${specId}', () => {`;
-  } else if (framework === 'cypress') {
+  } else if (resolvedFramework === 'cypress') {
     output += `\ndescribe('E2E: ${specId}', () => {`;
   }
 
@@ -325,7 +408,7 @@ export function generateE2eSkeleton(scenarios, { framework = 'vitest' } = {}) {
     output += template.test(s);
   }
 
-  if (framework === 'vitest' || framework === 'cypress') {
+  if (resolvedFramework === 'vitest' || resolvedFramework === 'cypress') {
     output += '});\n';
   }
 

package/src/utils/e2e-detector.js

@@ -1,7 +1,20 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 
-const SUPPORTED_FRAMEWORKS = ['playwright', 'cypress', 'vitest'];
+const SUPPORTED_FRAMEWORKS = [
+  // JavaScript/TypeScript
+  'playwright', 'cypress', 'vitest', 'webdriverio',
+  // Python
+  'pytest-playwright', 'selenium-python', 'robot-framework', 'behave',
+  // Java
+  'selenium-java', 'playwright-java', 'gauge',
+  // Go
+  'chromedp', 'rod',
+  // C#
+  'playwright-dotnet', 'selenium-dotnet',
+  // Ruby
+  'capybara', 'watir',
+];
 
 /**
  * Detect E2E testing frameworks in the project
@@ -11,6 +24,65 @@ const SUPPORTED_FRAMEWORKS = ['playwright', 'cypress', 'vitest'];
 export function detectE2eFramework(projectPath) {
   const detected = [];
 
+  // Python ecosystem detection
+  const pythonFiles = ['requirements.txt', 'pyproject.toml'];
+  for (const pyFile of pythonFiles) {
+    const pyPath = join(projectPath, pyFile);
+    if (existsSync(pyPath)) {
+      try {
+        const content = readFileSync(pyPath, 'utf-8');
+        if (content.includes('pytest-playwright')) detected.push('pytest-playwright');
+        if (content.includes('selenium')) detected.push('selenium-python');
+        if (content.includes('robotframework')) detected.push('robot-framework');
+        if (content.includes('behave')) detected.push('behave');
+      } catch {
+        // Ignore read errors
+      }
+      break;
+    }
+  }
+
+  // Go ecosystem detection
+  const goModPath = join(projectPath, 'go.mod');
+  if (existsSync(goModPath)) {
+    try {
+      const content = readFileSync(goModPath, 'utf-8');
+      if (content.includes('chromedp')) detected.push('chromedp');
+      if (content.includes('/rod')) detected.push('rod');
+    } catch {
+      // Ignore read errors
+    }
+  }
+
+  // Java ecosystem detection
+  for (const javaFile of ['pom.xml', 'build.gradle']) {
+    const javaPath = join(projectPath, javaFile);
+    if (existsSync(javaPath)) {
+      try {
+        const content = readFileSync(javaPath, 'utf-8');
+        if (content.includes('selenium')) detected.push('selenium-java');
+        if (content.includes('playwright')) detected.push('playwright-java');
+        if (content.includes('gauge')) detected.push('gauge');
+      } catch {
+        // Ignore read errors
+      }
+      break;
+    }
+  }
+
+  // Ruby ecosystem detection
+  const gemfilePath = join(projectPath, 'Gemfile');
+  if (existsSync(gemfilePath)) {
+    try {
+      const content = readFileSync(gemfilePath, 'utf-8');
+      if (content.includes('capybara')) detected.push('capybara');
+      if (content.includes('watir')) detected.push('watir');
+    } catch {
+      // Ignore read errors
+    }
+  }
+
+  // JavaScript/TypeScript ecosystem detection
   const packagePath = join(projectPath, 'package.json');
   if (existsSync(packagePath)) {
     try {

package/src/utils/integration-generator.js

@@ -3097,6 +3097,24 @@ export function getToolFilePath(tool) {
 
 
 
+/**
+ * Get default commands based on ecosystem
+ * @param {'node'|'python'|'go'|'java_maven'|'java_gradle'|'rust'|'ruby'} ecosystem
+ * @returns {{ test: string, lint: string, build: string, install: string }}
+ */
+function getDefaultCommands(ecosystem) {
+  const commands = {
+    node: { test: 'npm test', lint: 'npm run lint', build: 'npm run build', install: 'npm install' },
+    python: { test: 'python -m pytest', lint: 'python -m ruff check .', build: 'python -m build', install: 'pip install -r requirements.txt' },
+    go: { test: 'go test ./...', lint: 'go vet ./...', build: 'go build ./...', install: 'go mod download' },
+    java_maven: { test: 'mvn test', lint: 'mvn checkstyle:check', build: 'mvn package', install: 'mvn dependency:resolve' },
+    java_gradle: { test: './gradlew test', lint: './gradlew checkstyleMain', build: './gradlew build', install: './gradlew dependencies' },
+    rust: { test: 'cargo test', lint: 'cargo clippy', build: 'cargo build', install: 'cargo fetch' },
+    ruby: { test: 'bundle exec rspec', lint: 'bundle exec rubocop', build: 'gem build *.gemspec', install: 'bundle install' },
+  };
+  return commands[ecosystem] || commands.node;
+}
+
 /**
  * Detect build/test commands based on project files
  * @param {string} [projectPath] - Project root path
@@ -3104,11 +3122,12 @@ export function getToolFilePath(tool) {
  */
 function detectBuildCommands(projectPath) {
   if (!projectPath) {
+    const defaultCmds = getDefaultCommands('node');
     return [
       '# Check project configuration for build commands',
-      'npm install      # Install dependencies (Node.js)',
-      'npm test         # Run tests',
-      'npm run lint     # Check code style'
+      `${defaultCmds.install}      # Install dependencies (Node.js)`,
+      `${defaultCmds.test}         # Run tests`,
+      `${defaultCmds.lint}     # Check code style`
     ];
   }