amazingteam 3.0.0

package/action/__tests__/validator.test.js

@@ -0,0 +1,310 @@
+/**
+ * Validator Module Tests
+ */
+
+const {
+  validateAgainstSchema,
+  validateConfig,
+  validateRequiredFiles,
+  validateProjectStructure
+} = require('../lib/validator');
+
+function testValidateAgainstSchema_TypeValidation() {
+  console.log('Testing validateAgainstSchema type validation...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      count: { type: 'integer' },
+      active: { type: 'boolean' }
+    }
+  };
+  
+  const validValue = {
+    name: 'test',
+    count: 42,
+    active: true
+  };
+  
+  const result = validateAgainstSchema(validValue, schema);
+  console.assert(result.valid === true, 'Valid object should pass');
+  console.assert(result.errors.length === 0, 'Should have no errors');
+  
+  const invalidValue = {
+    name: 123,
+    count: 'not a number',
+    active: 'yes'
+  };
+  
+  const invalidResult = validateAgainstSchema(invalidValue, schema);
+  console.assert(invalidResult.valid === false, 'Invalid object should fail');
+  console.assert(invalidResult.errors.length > 0, 'Should have errors');
+  
+  console.log('  ✓ type validation tests passed');
+}
+
+function testValidateAgainstSchema_EnumValidation() {
+  console.log('Testing validateAgainstSchema enum validation...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      role: { enum: ['admin', 'user', 'guest'] },
+      status: { enum: ['active', 'inactive'] }
+    }
+  };
+  
+  const valid = { role: 'admin', status: 'active' };
+  const validResult = validateAgainstSchema(valid, schema);
+  console.assert(validResult.valid === true, 'Valid enum values should pass');
+  
+  const invalid = { role: 'superuser', status: 'active' };
+  const invalidResult = validateAgainstSchema(invalid, schema);
+  console.assert(invalidResult.valid === false, 'Invalid enum should fail');
+  console.assert(invalidResult.errors[0].includes('must be one of'), 'Error should mention enum values');
+  
+  console.log('  ✓ enum validation tests passed');
+}
+
+function testValidateAgainstSchema_StringValidation() {
+  console.log('Testing validateAgainstSchema string validation...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      name: { type: 'string', minLength: 3, maxLength: 10 },
+      email: { type: 'string', pattern: '^[a-z]+@[a-z]+\\.[a-z]+$' }
+    }
+  };
+  
+  const validName = { name: 'test' };
+  const validNameResult = validateAgainstSchema(validName, schema);
+  console.assert(validNameResult.valid === true, 'Valid string length should pass');
+  
+  const shortName = { name: 'ab' };
+  const shortResult = validateAgainstSchema(shortName, schema);
+  console.assert(shortResult.valid === false, 'Too short string should fail');
+  console.assert(shortResult.errors[0].includes('minLength'), 'Error should mention minLength');
+  
+  const longName = { name: 'verylongname' };
+  const longResult = validateAgainstSchema(longName, schema);
+  console.assert(longResult.valid === false, 'Too long string should fail');
+  
+  const validEmail = { email: 'test@example.com' };
+  const validEmailResult = validateAgainstSchema(validEmail, schema);
+  console.assert(validEmailResult.valid === true, 'Valid email pattern should pass');
+  
+  const invalidEmail = { email: 'invalid-email' };
+  const invalidEmailResult = validateAgainstSchema(invalidEmail, schema);
+  console.assert(invalidEmailResult.valid === false, 'Invalid email pattern should fail');
+  
+  console.log('  ✓ string validation tests passed');
+}
+
+function testValidateAgainstSchema_NumberValidation() {
+  console.log('Testing validateAgainstSchema number validation...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      age: { type: 'integer', minimum: 0, maximum: 150 },
+      score: { type: 'number', minimum: 0, maximum: 100 }
+    }
+  };
+  
+  const valid = { age: 25, score: 85.5 };
+  const validResult = validateAgainstSchema(valid, schema);
+  console.assert(validResult.valid === true, 'Valid numbers should pass');
+  
+  const negativeAge = { age: -5 };
+  const negativeResult = validateAgainstSchema(negativeAge, schema);
+  console.assert(negativeResult.valid === false, 'Negative age should fail');
+  console.assert(negativeResult.errors[0].includes('minimum'), 'Error should mention minimum');
+  
+  const overMax = { score: 150 };
+  const overMaxResult = validateAgainstSchema(overMax, schema);
+  console.assert(overMaxResult.valid === false, 'Over maximum should fail');
+  
+  const nonInteger = { age: 25.5 };
+  const nonIntResult = validateAgainstSchema(nonInteger, schema);
+  console.assert(nonIntResult.valid === false, 'Non-integer age should fail');
+  
+  console.log('  ✓ number validation tests passed');
+}
+
+function testValidateAgainstSchema_ArrayValidation() {
+  console.log('Testing validateAgainstSchema array validation...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        minItems: 1,
+        maxItems: 5
+      }
+    }
+  };
+  
+  const valid = { tags: ['a', 'b', 'c'] };
+  const validResult = validateAgainstSchema(valid, schema);
+  console.assert(validResult.valid === true, 'Valid array should pass');
+  
+  const empty = { tags: [] };
+  const emptyResult = validateAgainstSchema(empty, schema);
+  console.assert(emptyResult.valid === false, 'Empty array should fail (minItems)');
+  
+  const tooMany = { tags: ['1', '2', '3', '4', '5', '6'] };
+  const tooManyResult = validateAgainstSchema(tooMany, schema);
+  console.assert(tooManyResult.valid === false, 'Array with too many items should fail');
+  
+  const invalidItems = { tags: ['a', 123, 'b'] };
+  const invalidItemsResult = validateAgainstSchema(invalidItems, schema);
+  console.assert(invalidItemsResult.valid === false, 'Array with invalid items should fail');
+  
+  console.log('  ✓ array validation tests passed');
+}
+
+function testValidateAgainstSchema_RequiredProperties() {
+  console.log('Testing validateAgainstSchema required properties...');
+  
+  const schema = {
+    type: 'object',
+    required: ['name', 'version'],
+    properties: {
+      name: { type: 'string' },
+      version: { type: 'string' },
+      optional: { type: 'string' }
+    }
+  };
+  
+  const valid = { name: 'test', version: '1.0' };
+  const validResult = validateAgainstSchema(valid, schema);
+  console.assert(validResult.valid === true, 'Object with required properties should pass');
+  
+  const missingVersion = { name: 'test' };
+  const missingResult = validateAgainstSchema(missingVersion, schema);
+  console.assert(missingResult.valid === false, 'Missing required property should fail');
+  console.assert(missingResult.errors[0].includes('required'), 'Error should mention required');
+  
+  console.log('  ✓ required properties tests passed');
+}
+
+function testValidateAgainstSchema_NestedObjects() {
+  console.log('Testing validateAgainstSchema nested objects...');
+  
+  const schema = {
+    type: 'object',
+    properties: {
+      project: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          language: { type: 'string' }
+        },
+        required: ['name']
+      }
+    }
+  };
+  
+  const valid = { project: { name: 'my-project', language: 'typescript' } };
+  const validResult = validateAgainstSchema(valid, schema);
+  console.assert(validResult.valid === true, 'Valid nested object should pass');
+  
+  const missingNested = { project: { language: 'typescript' } };
+  const missingResult = validateAgainstSchema(missingNested, schema);
+  console.assert(missingResult.valid === false, 'Missing nested required property should fail');
+  
+  console.log('  ✓ nested objects tests passed');
+}
+
+function testValidateConfig() {
+  console.log('Testing validateConfig...');
+  
+  const schema = {
+    type: 'object',
+    required: ['version', 'project'],
+    properties: {
+      version: { type: 'string' },
+      project: {
+        type: 'object',
+        required: ['name'],
+        properties: {
+          name: { type: 'string' },
+          language: { type: 'string' }
+        }
+      }
+    }
+  };
+  
+  const validConfig = {
+    version: '1.0',
+    project: {
+      name: 'test-project',
+      language: 'typescript'
+    }
+  };
+  
+  const result = validateConfig(validConfig, schema);
+  console.assert(result.valid === true, 'Valid config should pass');
+  
+  const invalidConfig = {
+    version: '1.0'
+  };
+  
+  const invalidResult = validateConfig(invalidConfig, schema);
+  console.assert(invalidResult.valid === false, 'Invalid config should fail');
+  
+  console.log('  ✓ validateConfig tests passed');
+}
+
+function testValidateRequiredFiles() {
+  console.log('Testing validateRequiredFiles...');
+  
+  const result = validateRequiredFiles(process.cwd(), ['package.json']);
+  console.assert(result.valid === true, 'package.json should exist');
+  console.assert(result.missing.length === 0, 'Should have no missing files');
+  
+  const missingResult = validateRequiredFiles(process.cwd(), ['nonexistent-file.xyz']);
+  console.assert(missingResult.valid === false, 'Non-existent file should fail');
+  console.assert(missingResult.missing.length === 1, 'Should have one missing file');
+  
+  console.log('  ✓ validateRequiredFiles tests passed');
+}
+
+function testValidateProjectStructure() {
+  console.log('Testing validateProjectStructure...');
+  
+  const result = validateProjectStructure(process.cwd());
+  
+  console.assert(Array.isArray(result.issues), 'Should return issues array');
+  
+  if (result.valid) {
+    console.log('  Project structure is valid');
+  } else {
+    console.log(`  Project has issues: ${result.issues.join(', ')}`);
+  }
+  
+  console.log('  ✓ validateProjectStructure tests passed');
+}
+
+function runAll() {
+  console.log('\n=== Validator Module Tests ===\n');
+  
+  testValidateAgainstSchema_TypeValidation();
+  testValidateAgainstSchema_EnumValidation();
+  testValidateAgainstSchema_StringValidation();
+  testValidateAgainstSchema_NumberValidation();
+  testValidateAgainstSchema_ArrayValidation();
+  testValidateAgainstSchema_RequiredProperties();
+  testValidateAgainstSchema_NestedObjects();
+  testValidateConfig();
+  testValidateRequiredFiles();
+  testValidateProjectStructure();
+  
+  console.log('\n✅ All validator tests passed!\n');
+}
+
+runAll();

package/action/action.yml

@@ -0,0 +1,61 @@
+# AmazingTeam Foundation GitHub Action
+# Downloads and sets up AmazingTeam Foundation for use in workflows
+
+name: 'AmazingTeam Setup'
+description: 'Set up AmazingTeam Foundation for AI-powered development'
+author: 'AmazingTeam'
+branding:
+  icon: 'cpu'
+  color: 'blue'
+
+inputs:
+  version:
+    description: 'AmazingTeam Foundation version to use'
+    required: false
+    default: '3.0.0'
+  
+  config:
+    description: 'Path to amazingteam.config.yaml'
+    required: false
+    default: 'amazingteam.config.yaml'
+  
+  overlay:
+    description: 'Technology overlay to apply (e.g., python-backend, web-fullstack)'
+    required: false
+    default: ''
+  
+  cache:
+    description: 'Enable caching of foundation downloads'
+    required: false
+    default: 'true'
+  
+  cache-dir:
+    description: 'Directory to cache foundation downloads'
+    required: false
+    default: '~/.amazingteam-cache'
+
+outputs:
+  foundation-path:
+    description: 'Path to the downloaded foundation'
+    value: ${{ steps.setup.outputs.foundation-path }}
+  
+  setup-complete:
+    description: 'Whether setup completed successfully'
+    value: ${{ steps.setup.outputs.success }}
+  
+  version:
+    description: 'Foundation version that was set up'
+    value: ${{ steps.setup.outputs.version }}
+
+runs:
+  using: 'node20'
+  main: 'index.js'
+
+# Future: Support composite action for more complex setup
+# runs:
+#   using: 'composite'
+#   steps:
+#     - name: Setup AmazingTeam
+#       shell: bash
+#       run: |
+#         node ${{ github.action_path }}/index.js

package/action/index.js

@@ -0,0 +1,223 @@
+/**
+ * AmazingTeam Foundation GitHub Action
+ * Main entry point for the action
+ */
+
+const core = require('@actions/core');
+const github = require('@actions/github');
+const fs = require('fs');
+const path = require('path');
+
+const downloader = require('./lib/downloader');
+const merger = require('./lib/merger');
+const setup = require('./lib/setup');
+const validator = require('./lib/validator');
+const PathResolver = require('./lib/path-resolver');
+
+/**
+ * Parse YAML config (minimal implementation)
+ * For production, use js-yaml package
+ */
+function parseYamlConfig(content) {
+  const lines = content.split('\n');
+  const result = {};
+  let currentPath = [];
+  let currentIndent = 0;
+  
+  function setValue(obj, keys, value) {
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!current[keys[i]]) {
+        current[keys[i]] = {};
+      }
+      current = current[keys[i]];
+    }
+    current[keys[keys.length - 1]] = value;
+  }
+  
+  for (const line of lines) {
+    if (line.trim().startsWith('#') || line.trim() === '') continue;
+    
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+    const colonIndex = trimmed.indexOf(':');
+    
+    if (colonIndex > 0) {
+      const key = trimmed.substring(0, colonIndex).trim();
+      let value = trimmed.substring(colonIndex + 1).trim();
+      
+      // Adjust path based on indent
+      const level = Math.floor(indent / 2);
+      currentPath = currentPath.slice(0, level);
+      currentPath.push(key);
+      
+      if (value !== '') {
+        // Parse value
+        let parsedValue;
+        if (value.startsWith('[') && value.endsWith(']')) {
+          parsedValue = value.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+        } else if (value === 'true') {
+          parsedValue = true;
+        } else if (value === 'false') {
+          parsedValue = false;
+        } else if (value === 'null') {
+          parsedValue = null;
+        } else if (!isNaN(Number(value))) {
+          parsedValue = Number(value);
+        } else {
+          parsedValue = value.replace(/^["']|["']$/g, '');
+        }
+        
+        setValue(result, currentPath, parsedValue);
+        currentPath.pop();
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Load user configuration
+ */
+async function loadUserConfig(configPath, projectDir) {
+  const fullPath = path.join(projectDir, configPath);
+  
+  if (!fs.existsSync(fullPath)) {
+    core.warning(`Config file not found: ${configPath}, using defaults`);
+    return {};
+  }
+  
+  const content = fs.readFileSync(fullPath, 'utf-8');
+  return parseYamlConfig(content);
+}
+
+/**
+ * Load preset configuration
+ */
+async function loadPreset(presetName, foundationDir) {
+  if (!presetName) {
+    return null;
+  }
+  
+  const presetPath = path.join(foundationDir, 'presets', `${presetName}.yaml`);
+  
+  if (!fs.existsSync(presetPath)) {
+    core.warning(`Preset not found: ${presetName}`);
+    return null;
+  }
+  
+  const content = fs.readFileSync(presetPath, 'utf-8');
+  return parseYamlConfig(content);
+}
+
+/**
+ * Load default configuration
+ */
+async function loadDefaultConfig(foundationDir) {
+  const defaultPath = path.join(foundationDir, 'presets', 'default.yaml');
+  
+  if (!fs.existsSync(defaultPath)) {
+    core.warning('Default preset not found, using minimal config');
+    return {
+      version: '1.0',
+      project: {
+        name: 'unknown',
+        language: 'typescript'
+      }
+    };
+  }
+  
+  const content = fs.readFileSync(defaultPath, 'utf-8');
+  return parseYamlConfig(content);
+}
+
+/**
+ * Main action function
+ */
+async function run() {
+  try {
+    // Get inputs
+    const version = core.getInput('version') || '3.0.0';
+    const configPath = core.getInput('config') || 'amazingteam.config.yaml';
+    const overlay = core.getInput('overlay') || '';
+    const useCache = core.getInput('cache') !== 'false';
+    const cacheDir = core.getInput('cache-dir') || path.join(process.env.HOME || '', '.amazingteam-cache');
+    
+    const projectDir = process.env.GITHUB_WORKSPACE || process.cwd();
+    
+    core.info(`Setting up AmazingTeam Foundation v${version}`);
+    core.info(`Project directory: ${projectDir}`);
+    
+    // Step 1: Download foundation
+    core.info('Downloading foundation...');
+    const foundationDir = await downloader.downloadFoundation({
+      version,
+      cacheDir: useCache ? cacheDir : null
+    });
+    core.info(`Foundation downloaded to: ${foundationDir}`);
+    
+    // Step 2: Load configurations
+    core.info('Loading configurations...');
+    const defaultConfig = await loadDefaultConfig(foundationDir);
+    const presetConfig = overlay ? await loadPreset(overlay, foundationDir) : null;
+    const userConfig = await loadUserConfig(configPath, projectDir);
+    
+    // Step 3: Merge configurations
+    core.info('Merging configurations...');
+    const mergedConfig = merger.mergeWithPreset(presetConfig, defaultConfig, userConfig);
+    
+    // Validate merged config
+    const validation = merger.validateMergedConfig(mergedConfig);
+    if (!validation.valid) {
+      core.warning(`Configuration validation warnings: ${validation.errors.join(', ')}`);
+    }
+    
+    // Step 4: Setup runtime
+    core.info('Setting up runtime...');
+    const setupResult = setup.setup(foundationDir, projectDir, mergedConfig);
+    
+    // Step 5: Verify setup
+    const verification = setup.verifySetup(projectDir);
+    if (!verification.valid) {
+      core.warning(`Setup verification issues: ${verification.issues.join(', ')}`);
+    }
+    
+    // Set outputs
+    core.setOutput('foundation-path', foundationDir);
+    core.setOutput('setup-complete', 'true');
+    core.setOutput('version', version);
+    
+    // Export environment variables for subsequent steps
+    core.exportVariable('AI_TEAM_FOUNDATION_PATH', foundationDir);
+    core.exportVariable('AI_TEAM_VERSION', version);
+    
+    core.info('AmazingTeam Foundation setup complete!');
+    
+    // Summary
+    core.summary.addRaw(`
+## AmazingTeam Foundation Setup Complete
+
+| Property | Value |
+|----------|-------|
+| Version | ${version} |
+| Foundation Path | ${foundationDir} |
+| Config | ${configPath} |
+| Overlay | ${overlay || 'none'} |
+
+### Created Directories
+${setupResult.createdDirectories.map(d => `- ${d}`).join('\n')}
+
+### Generated Files
+- ${setupResult.opencodePath}
+`).write();
+    
+  } catch (error) {
+    core.setFailed(`AmazingTeam setup failed: ${error.message}`);
+    core.error(error.stack);
+    process.exit(1);
+  }
+}
+
+// Run the action
+run();