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

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/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`
     ];
   }