amazingteam 3.0.0

package/cli/commands/upgrade.cjs

@@ -0,0 +1,213 @@
+/**
+ * Upgrade Command
+ * Upgrade to a new version
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const VERSION = require('../../package.json').version;
+const PACKAGE_NAME = 'amazingteam';
+const REGISTRY = 'https://registry.npmjs.org';
+
+function getLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const url = `${REGISTRY}/${PACKAGE_NAME}/latest`;
+    
+    https.get(url, {
+      timeout: 10000,
+      headers: {
+        'User-Agent': `${PACKAGE_NAME}-cli/${VERSION}`
+      }
+    }, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Registry returned ${response.statusCode}`));
+        return;
+      }
+      
+      let data = '';
+      response.on('data', chunk => { data += chunk; });
+      response.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          resolve(pkg.version);
+        } catch (err) {
+          reject(new Error('Failed to parse registry response'));
+        }
+      });
+    }).on('error', reject).on('timeout', () => {
+      reject(new Error('Registry request timeout'));
+    });
+  });
+}
+
+function compareVersions(a, b) {
+  const [aM, aN, aP] = a.split('.').map(Number);
+  const [bM, bN, bP] = b.split('.').map(Number);
+  
+  if (aM !== bM) return aM - bM;
+  if (aN !== bN) return aN - bN;
+  return aP - bP;
+}
+
+function getVersionDiff(from, to) {
+  const [fM, fN, fP] = from.split('.').map(Number);
+  const [tM, tN, tP] = to.split('.').map(Number);
+  
+  if (tM > fM) return 'major';
+  if (tN > fN) return 'minor';
+  return 'patch';
+}
+
+async function run(options, positional) {
+  const projectPath = process.cwd();
+  const configPath = path.join(projectPath, 'amazingteam.config.yaml');
+  const workflowPath = path.join(projectPath, '.github', 'workflows', 'amazingteam.yml');
+  
+  // Check if initialized
+  if (!fs.existsSync(configPath)) {
+    console.error('\n❌ AmazingTeam not initialized in this directory.');
+    console.error('   Run "amazingteam init" first.\n');
+    process.exit(1);
+  }
+  
+  const targetVersion = options.to;
+  const dryRun = options.dryRun;
+  
+  console.log('\n🔄 AmazingTeam Upgrade\n');
+  
+  // Determine target version
+  let newVersion;
+  try {
+    newVersion = targetVersion || await getLatestVersion();
+  } catch (error) {
+    console.error('❌ Failed to get latest version:', error.message);
+    process.exit(1);
+  }
+  
+  // Read current version from config
+  let currentVersion = VERSION;
+  const configContent = fs.readFileSync(configPath, 'utf-8');
+  const versionMatch = configContent.match(/version:\s*["']?(\d+\.\d+\.\d+)/);
+  if (versionMatch) {
+    currentVersion = versionMatch[1];
+  }
+  
+  console.log(`Current version: ${currentVersion}`);
+  console.log(`Target version:   ${newVersion}`);
+  
+  // Check if already up to date
+  if (compareVersions(currentVersion, newVersion) >= 0 && !options.force) {
+    console.log('\n✅ Already up to date!\n');
+    return;
+  }
+  
+  // Check for breaking changes
+  const diff = getVersionDiff(currentVersion, newVersion);
+  if (diff === 'major') {
+    console.log('\n⚠️  MAJOR version upgrade detected!');
+    console.log('   This may contain breaking changes.');
+    console.log('   Please review the changelog before proceeding.\n');
+  }
+  
+  if (dryRun) {
+    console.log('\n📝 Dry run - showing changes that would be made:\n');
+  } else {
+    console.log('\n📦 Upgrading...\n');
+  }
+  
+  const changes = [];
+  
+  // Update amazingteam.config.yaml
+  if (fs.existsSync(configPath)) {
+    let content = fs.readFileSync(configPath, 'utf-8');
+    const oldContent = content;
+    
+    content = content.replace(
+      /version:\s*["']?\d+\.\d+\.\d+["']?/g,
+      `version: "${newVersion}"`
+    );
+    
+    if (content !== oldContent) {
+      if (dryRun) {
+        console.log('  Would update: amazingteam.config.yaml');
+        console.log(`    version: ${currentVersion} → ${newVersion}`);
+      } else {
+        fs.writeFileSync(configPath, content);
+        console.log('  ✅ Updated: amazingteam.config.yaml');
+      }
+      changes.push('config');
+    }
+  }
+  
+  // Update workflow file
+  if (fs.existsSync(workflowPath)) {
+    let content = fs.readFileSync(workflowPath, 'utf-8');
+    const oldContent = content;
+    
+    // Update action version references
+    content = content.replace(
+      /amazingteam-action@v?\d+\.\d+\.\d+/g,
+      `amazingteam-action@v${newVersion}`
+    );
+    content = content.replace(
+      /version:\s*['"]?\d+\.\d+\.\d+['"]?/g,
+      `version: '${newVersion}'`
+    );
+    
+    if (content !== oldContent) {
+      if (dryRun) {
+        console.log('  Would update: .github/workflows/amazingteam.yml');
+        console.log(`    action: @v${currentVersion} → @v${newVersion}`);
+      } else {
+        fs.writeFileSync(workflowPath, content);
+        console.log('  ✅ Updated: .github/workflows/amazingteam.yml');
+      }
+      changes.push('workflow');
+    }
+  }
+  
+  if (changes.length === 0) {
+    console.log('  No changes needed.');
+  }
+  
+  if (!dryRun && changes.length > 0) {
+    console.log('\n✅ Upgrade complete!\n');
+    console.log('Next steps:');
+    console.log('  1. Review the changes');
+    console.log('  2. Run `amazingteam local` to download the new version');
+    console.log('  3. Test your project');
+    console.log('  4. Commit the changes\n');
+  } else if (dryRun) {
+    console.log('\nRun without --dry-run to apply changes.\n');
+  }
+}
+
+function help() {
+  return `
+amazingteam upgrade - Upgrade to a new version
+
+Usage:
+  amazingteam upgrade [options]
+
+Options:
+  --to <version>    Upgrade to specific version
+  --dry-run         Preview changes without applying
+  --force           Force upgrade even if already up to date
+
+Examples:
+  amazingteam upgrade                Upgrade to latest version
+  amazingteam upgrade --to 3.1.0     Upgrade to specific version
+  amazingteam upgrade --dry-run      Preview upgrade changes
+
+What gets updated:
+  - amazingteam.config.yaml version
+  - .github/workflows/amazingteam.yml action reference
+
+Note: After upgrading, run \`amazingteam local\` to download the new version
+for local development.
+`;
+}
+
+module.exports = { run, help };

package/cli/commands/validate.cjs

@@ -0,0 +1,259 @@
+/**
+ * Validate Command
+ * Validate configuration and project structure
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const VERSION = require('../../package.json').version;
+
+function validateConfig(configPath) {
+  const issues = [];
+  
+  if (!fs.existsSync(configPath)) {
+    return { valid: false, issues: ['amazingteam.config.yaml not found'] };
+  }
+  
+  const content = fs.readFileSync(configPath, 'utf-8');
+  
+  // Check required fields
+  if (!content.includes('version:')) {
+    issues.push('Missing required field: version');
+  }
+  
+  if (!content.includes('project:')) {
+    issues.push('Missing required field: project');
+  } else {
+    if (!content.match(/name:\s*["']?\w+/)) {
+      issues.push('Missing required field: project.name');
+    }
+    if (!content.match(/language:\s*["']?\w+/)) {
+      issues.push('Missing required field: project.language');
+    }
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+
+function validateStructure(projectPath) {
+  const issues = [];
+  
+  const requiredDirs = [
+    '.ai-team',
+    '.ai-team/memory',
+    'tasks'
+  ];
+  
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(path.join(projectPath, dir))) {
+      issues.push(`Missing directory: ${dir}`);
+    }
+  }
+  
+  const requiredFiles = [
+    'amazingteam.config.yaml',
+    '.github/workflows/amazingteam.yml'
+  ];
+  
+  for (const file of requiredFiles) {
+    if (!fs.existsSync(path.join(projectPath, file))) {
+      issues.push(`Missing file: ${file}`);
+    }
+  }
+  
+  const recommendedFiles = [
+    'opencode.jsonc',
+    'AGENTS.md',
+    '.gitignore'
+  ];
+  
+  const missingRecommended = recommendedFiles.filter(
+    file => !fs.existsSync(path.join(projectPath, file))
+  );
+  
+  return {
+    valid: issues.length === 0,
+    issues,
+    warnings: missingRecommended.map(f => `Recommended file missing: ${f}`)
+  };
+}
+
+function validateWorkflow(workflowPath) {
+  const issues = [];
+  
+  if (!fs.existsSync(workflowPath)) {
+    return { valid: false, issues: ['Workflow file not found'] };
+  }
+  
+  const content = fs.readFileSync(workflowPath, 'utf-8');
+  
+  // Check for required permissions
+  if (!content.includes('contents: write')) {
+    issues.push('Missing permission: contents: write');
+  }
+  if (!content.includes('pull-requests: write')) {
+    issues.push('Missing permission: pull-requests: write');
+  }
+  if (!content.includes('issues: write')) {
+    issues.push('Missing permission: issues: write');
+  }
+  
+  // Check for AmazingTeam action
+  if (!content.includes('amazingteam-action')) {
+    issues.push('AmazingTeam action not referenced in workflow');
+  }
+  
+  // Check for secrets
+  if (!content.includes('ALIBABA_CODING_PLAN_API_KEY') && 
+      !content.includes('OPENCODE_API_KEY')) {
+    issues.push('No API key secret referenced');
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+
+function validateGitignore(projectPath) {
+  const issues = [];
+  const warnings = [];
+  
+  const gitignorePath = path.join(projectPath, '.gitignore');
+  
+  if (!fs.existsSync(gitignorePath)) {
+    issues.push('.gitignore not found');
+    return { valid: false, issues, warnings };
+  }
+  
+  const content = fs.readFileSync(gitignorePath, 'utf-8');
+  
+  if (!content.includes('.ai-team-local/')) {
+    warnings.push('.ai-team-local/ not in .gitignore');
+  }
+  
+  if (!content.includes('.ai-team-cache/')) {
+    warnings.push('.ai-team-cache/ not in .gitignore');
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+
+async function run(options, positional) {
+  const projectPath = process.cwd();
+  const configPath = path.join(projectPath, 'amazingteam.config.yaml');
+  const workflowPath = path.join(projectPath, '.github', 'workflows', 'amazingteam.yml');
+  
+  console.log('\n🔍 Validating AmazingTeam setup\n');
+  
+  let allValid = true;
+  const allIssues = [];
+  const allWarnings = [];
+  
+  // Validate config
+  console.log('Checking configuration...');
+  const configResult = validateConfig(configPath);
+  if (configResult.valid) {
+    console.log('  ✅ Configuration valid');
+  } else {
+    console.log('  ❌ Configuration issues:');
+    configResult.issues.forEach(issue => {
+      console.log(`     - ${issue}`);
+    });
+    allIssues.push(...configResult.issues);
+    allValid = false;
+  }
+  
+  // Validate structure
+  console.log('Checking project structure...');
+  const structResult = validateStructure(projectPath);
+  if (structResult.valid) {
+    console.log('  ✅ Structure valid');
+  } else {
+    console.log('  ❌ Structure issues:');
+    structResult.issues.forEach(issue => {
+      console.log(`     - ${issue}`);
+    });
+    allIssues.push(...structResult.issues);
+    allValid = false;
+  }
+  if (structResult.warnings.length > 0) {
+    structResult.warnings.forEach(w => console.log(`  ⚠️  ${w}`));
+    allWarnings.push(...structResult.warnings);
+  }
+  
+  // Validate workflow
+  console.log('Checking workflow...');
+  const workflowResult = validateWorkflow(workflowPath);
+  if (workflowResult.valid) {
+    console.log('  ✅ Workflow valid');
+  } else {
+    console.log('  ❌ Workflow issues:');
+    workflowResult.issues.forEach(issue => {
+      console.log(`     - ${issue}`);
+    });
+    allIssues.push(...workflowResult.issues);
+    allValid = false;
+  }
+  
+  // Validate gitignore
+  console.log('Checking .gitignore...');
+  const gitignoreResult = validateGitignore(projectPath);
+  if (gitignoreResult.valid) {
+    console.log('  ✅ .gitignore valid');
+  } else {
+    gitignoreResult.issues.forEach(issue => {
+      console.log(`     - ${issue}`);
+    });
+    allIssues.push(...gitignoreResult.issues);
+    allValid = false;
+  }
+  if (gitignoreResult.warnings.length > 0) {
+    gitignoreResult.warnings.forEach(w => console.log(`  ⚠️  ${w}`));
+    allWarnings.push(...gitignoreResult.warnings);
+  }
+  
+  // Summary
+  console.log('\n' + '='.repeat(40));
+  
+  if (allValid && allWarnings.length === 0) {
+    console.log('✅ All validations passed!\n');
+  } else if (allValid) {
+    console.log(`✅ Valid (${allWarnings.length} warnings)\n`);
+  } else {
+    console.log(`❌ ${allIssues.length} issue(s) found\n`);
+    console.log('Fix the issues above and run validate again.\n');
+    process.exit(1);
+  }
+}
+
+function help() {
+  return `
+amazingteam validate - Validate configuration and project structure
+
+Usage:
+  amazingteam validate
+
+Validates:
+  - amazingteam.config.yaml configuration
+  - Required directories (.ai-team/, tasks/)
+  - GitHub workflow configuration
+  - .gitignore entries
+
+Exit codes:
+  0 - All validations passed
+  1 - Validation failures found
+
+Run this after initialization or upgrades to verify setup.
+`;
+}
+
+module.exports = { run, help };

package/cli/commands/version.cjs

@@ -0,0 +1,59 @@
+/**
+ * Version Command
+ * Show current foundation version
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const VERSION = require('../../package.json').version;
+
+function run(options, positional) {
+  const projectPath = process.cwd();
+  const configPath = path.join(projectPath, 'amazingteam.config.yaml');
+  const workflowPath = path.join(projectPath, '.github', 'workflows', 'amazingteam.yml');
+  
+  console.log(`\namazingteam v${VERSION}\n`);
+  
+  // Check project config
+  if (fs.existsSync(configPath)) {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const versionMatch = content.match(/version:\s*["']?(\d+\.\d+\.\d+)/);
+    if (versionMatch) {
+      console.log(`Project config version: ${versionMatch[1]}`);
+    }
+  }
+  
+  // Check workflow version
+  if (fs.existsSync(workflowPath)) {
+    const content = fs.readFileSync(workflowPath, 'utf-8');
+    const actionMatch = content.match(/amazingteam-action@v?(\d+\.\d+\.\d+)/);
+    if (actionMatch) {
+      console.log(`Workflow action version: ${actionMatch[1]}`);
+    }
+  }
+  
+  // Check if initialized
+  if (!fs.existsSync(configPath)) {
+    console.log('\n⚠️  AmazingTeam not initialized in this directory.');
+    console.log('   Run "amazingteam init" to get started.\n');
+  }
+}
+
+function help() {
+  return `
+amazingteam version - Show current foundation version
+
+Usage:
+  amazingteam version
+  ai-team --version
+  ai-team -v
+
+Displays:
+  - CLI version
+  - Project config version (if initialized)
+  - Workflow action version (if configured)
+`;
+}
+
+module.exports = { run, help };