universal-dev-standards 3.5.0-beta.4 → 3.5.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-dev-standards",
-  "version": "3.5.0-beta.4",
+  "version": "3.5.0-beta.5",
   "description": "CLI tool for adopting Universal Development Standards",
   "keywords": [
     "documentation",

package/src/commands/check.js

@@ -18,6 +18,11 @@ import {
   parseReferences,
   compareStandardsWithReferences
 } from '../utils/reference-sync.js';
+import {
+  getToolFilePath,
+  getToolFormat,
+  extractMarkedContent
+} from '../utils/integration-generator.js';
 
 /**
  * Check command - verify adoption status
@@ -211,6 +216,9 @@ export async function checkCommand(options = {}) {
   // Reference sync check
   checkReferenceSync(manifest, projectPath);
 
+  // Integration files check
+  checkIntegrationFiles(manifest, projectPath);
+
   // Skills status
   displaySkillsStatus(manifest, projectPath);
 
@@ -675,6 +683,132 @@ function displayCoverageReport(manifest) {
   console.log();
 }
 
+/**
+ * Check AI tool integration files for standards coverage
+ */
+function checkIntegrationFiles(manifest, projectPath) {
+  // Skip if no AI tools configured
+  if (!manifest.aiTools || manifest.aiTools.length === 0) {
+    return;
+  }
+
+  console.log(chalk.cyan('AI Tool Integration Status:'));
+
+  const standardsFiles = manifest.standards?.map(s => basename(s)) || [];
+  let hasIssues = false;
+  let checkedCount = 0;
+
+  // Standard filename to task mapping for coverage check
+  const STANDARD_TASK_MAPPING = {
+    'anti-hallucination.md': 'AI collaboration',
+    'commit-message.ai.yaml': 'Writing commits',
+    'checkin-standards.md': 'Committing code',
+    'logging-standards.md': 'Adding logging',
+    'error-code-standards.md': 'Error handling',
+    'testing.ai.yaml': 'Writing tests',
+    'versioning.md': 'Version bumping',
+    'changelog-standards.md': 'Updating changelog',
+    'code-review-checklist.md': 'Code review',
+    'spec-driven-development.md': 'Feature development',
+    'test-completeness-dimensions.md': 'Test coverage',
+    'git-workflow.ai.yaml': 'Git workflow'
+  };
+
+  for (const tool of manifest.aiTools) {
+    const toolFile = getToolFilePath(tool);
+    if (!toolFile) continue;
+
+    const fullPath = join(projectPath, toolFile);
+
+    // Check if file exists
+    if (!existsSync(fullPath)) {
+      console.log(chalk.red(`  ✗ ${toolFile}: File not found`));
+      hasIssues = true;
+      continue;
+    }
+
+    checkedCount++;
+
+    // Read file content
+    let content;
+    try {
+      content = readFileSync(fullPath, 'utf-8');
+    } catch {
+      console.log(chalk.yellow(`  ⚠ ${toolFile}: Could not read file`));
+      continue;
+    }
+
+    // Check for standards index marker
+    const format = getToolFormat(tool);
+    const { content: markedContent } = extractMarkedContent(content, format);
+    const hasStandardsIndex = markedContent.length > 0 ||
+      content.includes('Standards Index') ||
+      content.includes('Standards Compliance');
+
+    // Count referenced standards
+    const referencedStandards = [];
+    const missingStandards = [];
+
+    for (const stdFile of standardsFiles) {
+      // Check if standard is referenced in the file
+      const isReferenced = content.includes(stdFile) ||
+        content.includes(`.standards/${stdFile}`) ||
+        content.includes(`standards/${stdFile}`);
+
+      if (isReferenced) {
+        referencedStandards.push(stdFile);
+      } else if (STANDARD_TASK_MAPPING[stdFile]) {
+        // Only report as missing if it's a known trackable standard
+        missingStandards.push(stdFile);
+      }
+    }
+
+    // Report status
+    const totalTrackable = Object.keys(STANDARD_TASK_MAPPING).filter(s =>
+      standardsFiles.includes(s)
+    ).length;
+
+    if (hasStandardsIndex && missingStandards.length === 0) {
+      console.log(chalk.green(`  ✓ ${toolFile}:`));
+      console.log(chalk.gray('    Standards index present'));
+      console.log(chalk.gray(`    ${referencedStandards.length}/${totalTrackable || standardsFiles.length} standards referenced`));
+    } else if (hasStandardsIndex) {
+      console.log(chalk.yellow(`  ⚠ ${toolFile}:`));
+      console.log(chalk.gray('    Standards index present'));
+      console.log(chalk.yellow(`    ${referencedStandards.length}/${totalTrackable} standards referenced`));
+      if (missingStandards.length > 0 && missingStandards.length <= 5) {
+        console.log(chalk.yellow(`    Missing: ${missingStandards.join(', ')}`));
+      } else if (missingStandards.length > 5) {
+        console.log(chalk.yellow(`    Missing: ${missingStandards.slice(0, 5).join(', ')}...`));
+      }
+      hasIssues = true;
+    } else {
+      // No standards index - using minimal mode
+      console.log(chalk.gray(`  ℹ ${toolFile}:`));
+      console.log(chalk.gray('    Using minimal mode (no standards index)'));
+      const coreRules = content.includes('Anti-Hallucination') ||
+        content.includes('Commit') ||
+        content.includes('Code Review');
+      if (coreRules) {
+        console.log(chalk.gray('    Core rules embedded'));
+      }
+    }
+  }
+
+  if (checkedCount === 0) {
+    console.log(chalk.gray('  No AI tool integration files configured.'));
+  }
+
+  if (hasIssues) {
+    console.log();
+    console.log(chalk.yellow('  To fix integration issues:'));
+    console.log(chalk.gray('    • Run `uds update` to sync all integration files'));
+    console.log(chalk.gray('    • Run `uds configure --type ai_tools` to manage AI tools'));
+  }
+
+  console.log();
+}
+
 /**
  * Check reference sync status between manifest standards and integration files
  */

package/src/commands/configure.js

@@ -1,9 +1,13 @@
 import chalk from 'chalk';
 import ora from 'ora';
+import { unlinkSync, existsSync } from 'fs';
+import { join, basename } from 'path';
 import {
   getOptionSource,
   findOption,
-  getAllStandards
+  getAllStandards,
+  getStandardsByLevel,
+  getStandardSource
 } from '../utils/registry.js';
 import {
   copyStandard,
@@ -17,8 +21,16 @@ import {
   promptMergeStrategy,
   promptCommitLanguage,
   promptTestLevels,
-  promptConfirm
+  promptConfirm,
+  promptManageAITools,
+  promptAdoptionLevel,
+  promptContentModeChange,
+  handleAgentsMdSharing
 } from '../prompts/init.js';
+import {
+  writeIntegrationFile,
+  getToolFilePath
+} from '../utils/integration-generator.js';
 
 /**
  * Configure command - modify options for initialized project
@@ -47,7 +59,10 @@ export async function configureCommand(options) {
 
   console.log();
   console.log(chalk.cyan('Current Configuration:'));
+  console.log(chalk.gray(`  Level: ${manifest.level || 2}`));
   console.log(chalk.gray(`  Format: ${manifest.format || 'human'}`));
+  console.log(chalk.gray(`  Content Mode: ${manifest.contentMode || 'minimal'}`));
+  console.log(chalk.gray(`  AI Tools: ${manifest.aiTools?.length > 0 ? manifest.aiTools.join(', ') : 'none'}`));
   if (manifest.options) {
     if (manifest.options.workflow) {
       console.log(chalk.gray(`  Git Workflow: ${manifest.options.workflow}`));
@@ -80,6 +95,11 @@ export async function configureCommand(options) {
           { name: 'Merge Strategy', value: 'merge_strategy' },
           { name: 'Commit Message Language', value: 'commit_language' },
           { name: 'Test Levels', value: 'test_levels' },
+          new inquirer.default.Separator(),
+          { name: `${chalk.cyan('AI Tools')} - Add/Remove AI integrations`, value: 'ai_tools' },
+          { name: `${chalk.cyan('Adoption Level')} - Change Level 1/2/3`, value: 'level' },
+          { name: `${chalk.cyan('Content Mode')} - Change full/index/minimal`, value: 'content_mode' },
+          new inquirer.default.Separator(),
           { name: 'All Options', value: 'all' }
         ]
       }
@@ -90,7 +110,60 @@ export async function configureCommand(options) {
   // Collect new options
   const newOptions = { ...manifest.options };
   let newFormat = manifest.format;
+  let newLevel = manifest.level || 2;
+  let newContentMode = manifest.contentMode || 'minimal';
+  let newAITools = [...(manifest.aiTools || [])];
+  let needsIntegrationRegeneration = false;
+
+  // Handle AI Tools configuration
+  if (configType === 'ai_tools') {
+    const result = await promptManageAITools(manifest.aiTools || []);
+
+    if (result.action === 'add' && result.tools.length > 0) {
+      // Handle AGENTS.md sharing
+      const toolsWithSharing = handleAgentsMdSharing(result.tools);
+      newAITools = [...new Set([...newAITools, ...toolsWithSharing])];
+      needsIntegrationRegeneration = true;
+    } else if (result.action === 'remove' && result.tools.length > 0) {
+      newAITools = newAITools.filter(t => !result.tools.includes(t));
+
+      // Remove integration files for removed tools
+      const spinner = ora('Removing integration files...').start();
+      for (const tool of result.tools) {
+        const filePath = join(projectPath, getToolFilePath(tool));
+        if (existsSync(filePath)) {
+          try {
+            unlinkSync(filePath);
+            console.log(chalk.gray(`  Removed: ${getToolFilePath(tool)}`));
+          } catch (err) {
+            console.log(chalk.yellow(`  Could not remove: ${getToolFilePath(tool)}`));
+          }
+        }
+      }
+      spinner.succeed('Integration files removed');
+    } else if (result.action === 'view' || result.action === 'cancel') {
+      console.log(chalk.gray('No changes made.'));
+      process.exit(0);
+    }
+  }
 
+  // Handle Level configuration
+  if (configType === 'level') {
+    newLevel = await promptAdoptionLevel(manifest.level || 2);
+    if (newLevel !== manifest.level) {
+      needsIntegrationRegeneration = true;
+    }
+  }
+
+  // Handle Content Mode configuration
+  if (configType === 'content_mode') {
+    newContentMode = await promptContentModeChange(manifest.contentMode || 'minimal');
+    if (newContentMode !== manifest.contentMode) {
+      needsIntegrationRegeneration = true;
+    }
+  }
+
+  // Handle traditional options
   if (configType === 'all' || configType === 'format') {
     newFormat = await promptFormat();
   }
@@ -114,7 +187,10 @@ export async function configureCommand(options) {
   // Show changes
   console.log();
   console.log(chalk.cyan('New Configuration:'));
+  console.log(chalk.gray(`  Level: ${newLevel}`));
   console.log(chalk.gray(`  Format: ${newFormat}`));
+  console.log(chalk.gray(`  Content Mode: ${newContentMode}`));
+  console.log(chalk.gray(`  AI Tools: ${newAITools.length > 0 ? newAITools.join(', ') : 'none'}`));
   if (newOptions.workflow) {
     console.log(chalk.gray(`  Git Workflow: ${newOptions.workflow}`));
   }
@@ -133,7 +209,7 @@ export async function configureCommand(options) {
   const confirmed = await promptConfirm('Apply these changes?');
   if (!confirmed) {
     console.log(chalk.yellow('Configuration cancelled.'));
-    return;
+    process.exit(0);
   }
 
   // Apply changes
@@ -141,6 +217,7 @@ export async function configureCommand(options) {
 
   const results = {
     copied: [],
+    generated: [],
     errors: []
   };
 
@@ -194,10 +271,78 @@ export async function configureCommand(options) {
     }
   }
 
+  // Handle level change - copy new standards if upgrading
+  if (newLevel > (manifest.level || 2)) {
+    const levelSpinner = ora('Adding new standards for higher level...').start();
+    const newStandards = getStandardsByLevel(newLevel);
+    const existingStandards = new Set(manifest.standards?.map(s => basename(s)) || []);
+
+    for (const std of newStandards) {
+      for (const targetFormat of formatsToUse) {
+        const sourcePath = getStandardSource(std, targetFormat);
+        const fileName = basename(sourcePath);
+        if (!existingStandards.has(fileName)) {
+          const result = await copyStandard(sourcePath, '.standards', projectPath);
+          if (result.success) {
+            results.copied.push(sourcePath);
+          }
+        }
+      }
+    }
+    levelSpinner.succeed('New standards added');
+  }
+
+  // Regenerate integration files if needed
+  if (needsIntegrationRegeneration && newAITools.length > 0) {
+    const intSpinner = ora('Regenerating integration files...').start();
+
+    // Build installed standards list
+    const installedStandardsList = manifest.standards?.map(s => basename(s)) || [];
+
+    // Determine language setting
+    let commonLanguage = 'en';
+    if (newOptions.commit_language === 'bilingual') {
+      commonLanguage = 'bilingual';
+    } else if (newOptions.commit_language === 'traditional-chinese') {
+      commonLanguage = 'zh-tw';
+    }
+
+    // Track generated files to handle AGENTS.md sharing
+    const generatedFiles = new Set();
+
+    for (const tool of newAITools) {
+      const targetFile = getToolFilePath(tool);
+      if (generatedFiles.has(targetFile)) {
+        continue; // Skip if already generated (AGENTS.md sharing)
+      }
+
+      const toolConfig = {
+        tool,
+        categories: ['anti-hallucination', 'commit-standards', 'code-review'],
+        language: commonLanguage,
+        installedStandards: installedStandardsList,
+        contentMode: newContentMode,
+        level: newLevel
+      };
+
+      const result = writeIntegrationFile(tool, toolConfig, projectPath);
+      if (result.success) {
+        results.generated.push(result.path);
+        generatedFiles.add(targetFile);
+      } else {
+        results.errors.push(`${tool}: ${result.error}`);
+      }
+    }
+    intSpinner.succeed(`Regenerated ${results.generated.length} integration files`);
+  }
+
   // Update manifest
   manifest.format = newFormat;
   manifest.options = newOptions;
-  manifest.version = '2.0.0';
+  manifest.level = newLevel;
+  manifest.contentMode = newContentMode;
+  manifest.aiTools = newAITools;
+  manifest.version = '3.2.0';
   writeManifest(manifest, projectPath);
 
   spinner.succeed('Configuration updated');
@@ -206,7 +351,10 @@ export async function configureCommand(options) {
   console.log();
   console.log(chalk.green('✓ Configuration updated successfully!'));
   if (results.copied.length > 0) {
-    console.log(chalk.gray(`  ${results.copied.length} new option files copied`));
+    console.log(chalk.gray(`  ${results.copied.length} new option/standard files copied`));
+  }
+  if (results.generated.length > 0) {
+    console.log(chalk.gray(`  ${results.generated.length} integration files regenerated`));
   }
 
   if (results.errors.length > 0) {