amazingteam 3.0.0

package/action/lib/downloader.js

@@ -0,0 +1,344 @@
+/**
+ * Foundation Downloader Module
+ * Downloads AmazingTeam Foundation from NPM or GitHub
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Download options
+ * @typedef {Object} DownloadOptions
+ * @property {string} version - Foundation version
+ * @property {string} [registry] - NPM registry URL
+ * @property {string} [githubToken] - GitHub token for private repos
+ * @property {string} [cacheDir] - Cache directory
+ * @property {number} [retries] - Number of retries (default: 3)
+ * @property {number} [timeout] - Timeout in ms (default: 60000)
+ */
+
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const GITHUB_REPO = 'your-org/amazingteam';
+const DEFAULT_CACHE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.amazingteam-cache');
+const MAX_RETRIES = 3;
+const TIMEOUT = 60000; // 60 seconds
+
+/**
+ * Download a file from URL
+ * @param {string} url - URL to download
+ * @param {string} dest - Destination path
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<void>}
+ */
+function downloadFile(url, dest, timeout = TIMEOUT) {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+    
+    const request = protocol.get(url, {
+      timeout,
+      headers: {
+        'User-Agent': 'amazingteam-downloader/1.0'
+      }
+    }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        const redirectUrl = response.headers.location;
+        downloadFile(redirectUrl, dest, timeout).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (response.statusCode !== 200) {
+        reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+        return;
+      }
+      
+      const file = fs.createWriteStream(dest);
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    });
+    
+    request.on('error', (err) => {
+      fs.unlink(dest, () => {}); // Delete partial file
+      reject(err);
+    });
+    
+    request.on('timeout', () => {
+      request.destroy();
+      reject(new Error('Download timeout'));
+    });
+  });
+}
+
+/**
+ * Download from NPM registry
+ * @param {string} version - Foundation version
+ * @param {string} destDir - Destination directory
+ * @param {string} [registry] - NPM registry URL
+ * @returns {Promise<string>} Path to downloaded package
+ */
+async function downloadFromNpm(version, destDir, registry = DEFAULT_REGISTRY) {
+  const packageName = 'amazingteam';
+  const tarballUrl = `${registry}/${packageName}/-/${packageName}-${version}.tgz`;
+  const tarballPath = path.join(destDir, `${packageName}-${version}.tgz`);
+  
+  console.log(`Downloading from NPM: ${tarballUrl}`);
+  
+  await downloadFile(tarballUrl, tarballPath);
+  
+  // Extract tarball
+  const extractDir = path.join(destDir, 'package');
+  if (fs.existsSync(extractDir)) {
+    fs.rmSync(extractDir, { recursive: true });
+  }
+  
+  // Use tar command (available on most systems)
+  try {
+    execSync(`tar -xzf "${tarballPath}" -C "${destDir}"`, { stdio: 'inherit' });
+  } catch (err) {
+    throw new Error(`Failed to extract tarball: ${err.message}`);
+  }
+  
+  // Clean up tarball
+  fs.unlinkSync(tarballPath);
+  
+  return extractDir;
+}
+
+/**
+ * Download from GitHub releases
+ * @param {string} version - Foundation version
+ * @param {string} destDir - Destination directory
+ * @param {string} [githubToken] - GitHub token for private repos
+ * @returns {Promise<string>} Path to downloaded package
+ */
+async function downloadFromGitHub(version, destDir, githubToken) {
+  const tarballUrl = `https://github.com/${GITHUB_REPO}/archive/v${version}.tar.gz`;
+  const tarballPath = path.join(destDir, `amazingteam-${version}.tar.gz`);
+  
+  console.log(`Downloading from GitHub: ${tarballUrl}`);
+  
+  const headers = {
+    'User-Agent': 'amazingteam-downloader/1.0'
+  };
+  
+  if (githubToken) {
+    headers['Authorization'] = `token ${githubToken}`;
+  }
+  
+  await new Promise((resolve, reject) => {
+    const request = https.get(tarballUrl, {
+      headers,
+      timeout: TIMEOUT
+    }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        const redirectUrl = response.headers.location;
+        downloadFile(redirectUrl, tarballPath).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (response.statusCode !== 200) {
+        reject(new Error(`GitHub download failed: HTTP ${response.statusCode}`));
+        return;
+      }
+      
+      const file = fs.createWriteStream(tarballPath);
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    });
+    
+    request.on('error', reject);
+    request.on('timeout', () => {
+      request.destroy();
+      reject(new Error('GitHub download timeout'));
+    });
+  });
+  
+  // Extract tarball
+  try {
+    execSync(`tar -xzf "${tarballPath}" -C "${destDir}"`, { stdio: 'inherit' });
+  } catch (err) {
+    throw new Error(`Failed to extract GitHub tarball: ${err.message}`);
+  }
+  
+  // Clean up tarball
+  fs.unlinkSync(tarballPath);
+  
+  // GitHub extracts to amazingteam-{version}
+  const extractDir = path.join(destDir, `amazingteam-${version}`);
+  return extractDir;
+}
+
+/**
+ * Download with retry
+ * @param {Function} downloadFn - Download function
+ * @param {number} retries - Number of retries
+ * @returns {Promise<string>}
+ */
+async function withRetry(downloadFn, retries = MAX_RETRIES) {
+  let lastError;
+  
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await downloadFn();
+    } catch (err) {
+      lastError = err;
+      console.log(`Download attempt ${i + 1} failed: ${err.message}`);
+      if (i < retries - 1) {
+        const delay = Math.pow(2, i) * 1000; // Exponential backoff
+        console.log(`Retrying in ${delay}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Download foundation
+ * @param {DownloadOptions} options - Download options
+ * @returns {Promise<string>} Path to downloaded foundation
+ */
+async function downloadFoundation(options) {
+  const {
+    version,
+    registry = DEFAULT_REGISTRY,
+    githubToken,
+    cacheDir = DEFAULT_CACHE_DIR,
+    retries = MAX_RETRIES
+  } = options;
+  
+  // Create cache directory
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+  
+  // Check cache
+  const cachedPath = path.join(cacheDir, `v${version}`);
+  if (fs.existsSync(cachedPath)) {
+    console.log(`Using cached foundation v${version}`);
+    return cachedPath;
+  }
+  
+  // Create temp directory for download
+  const tempDir = path.join(cacheDir, 'temp');
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+  
+  let foundationPath;
+  
+  // Try NPM first, then GitHub
+  try {
+    foundationPath = await withRetry(() => downloadFromNpm(version, tempDir, registry), retries);
+  } catch (npmError) {
+    console.log(`NPM download failed: ${npmError.message}`);
+    console.log('Falling back to GitHub releases...');
+    
+    try {
+      foundationPath = await withRetry(() => downloadFromGitHub(version, tempDir, githubToken), retries);
+    } catch (githubError) {
+      throw new Error(`Both NPM and GitHub downloads failed. NPM: ${npmError.message}, GitHub: ${githubError.message}`);
+    }
+  }
+  
+  // Move to cache
+  fs.renameSync(foundationPath, cachedPath);
+  
+  // Clean up temp directory
+  fs.rmSync(tempDir, { recursive: true, force: true });
+  
+  return cachedPath;
+}
+
+/**
+ * Check if a version exists
+ * @param {string} version - Version to check
+ * @param {string} [registry] - NPM registry URL
+ * @returns {Promise<boolean>}
+ */
+async function versionExists(version, registry = DEFAULT_REGISTRY) {
+  const packageName = 'amazingteam';
+  const url = `${registry}/${packageName}/${version}`;
+  
+  return new Promise((resolve) => {
+    https.get(url, {
+      timeout: 10000,
+      headers: {
+        'User-Agent': 'amazingteam-downloader/1.0'
+      }
+    }, (response) => {
+      resolve(response.statusCode === 200);
+    }).on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Get latest version from NPM
+ * @param {string} [registry] - NPM registry URL
+ * @returns {Promise<string>} Latest version
+ */
+async function getLatestVersion(registry = DEFAULT_REGISTRY) {
+  const packageName = 'amazingteam';
+  const url = `${registry}/${packageName}/latest`;
+  
+  return new Promise((resolve, reject) => {
+    https.get(url, {
+      timeout: 10000,
+      headers: {
+        'User-Agent': 'amazingteam-downloader/1.0'
+      }
+    }, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to get latest version: HTTP ${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 response: ${err.message}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Clear download cache
+ * @param {string} [cacheDir] - Cache directory
+ */
+function clearCache(cacheDir = DEFAULT_CACHE_DIR) {
+  if (fs.existsSync(cacheDir)) {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+    console.log('Cache cleared');
+  }
+}
+
+module.exports = {
+  downloadFoundation,
+  downloadFromNpm,
+  downloadFromGitHub,
+  versionExists,
+  getLatestVersion,
+  clearCache,
+  DEFAULT_CACHE_DIR
+};

package/action/lib/merger.js

@@ -0,0 +1,170 @@
+/**
+ * Configuration Merger Module
+ * Merges user configuration with foundation defaults
+ */
+
+/**
+ * Check if value is a plain object
+ * @param {*} value 
+ * @returns {boolean}
+ */
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/**
+ * Deep clone an object
+ * @param {*} obj 
+ * @returns {*}
+ */
+function deepClone(obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+  
+  if (Array.isArray(obj)) {
+    return obj.map(item => deepClone(item));
+  }
+  
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    cloned[key] = deepClone(obj[key]);
+  }
+  return cloned;
+}
+
+/**
+ * Deep merge two objects
+ * User config overrides foundation defaults
+ * Arrays are replaced, not merged
+ * 
+ * @param {Object} foundationDefaults - Base configuration from foundation
+ * @param {Object} userConfig - User overrides
+ * @returns {Object} Merged configuration
+ */
+function mergeConfig(foundationDefaults, userConfig) {
+  const result = deepClone(foundationDefaults);
+  
+  if (!userConfig || typeof userConfig !== 'object') {
+    return result;
+  }
+  
+  for (const key of Object.keys(userConfig)) {
+    if (userConfig[key] === undefined || userConfig[key] === null) {
+      continue;
+    }
+    
+    // Handle $preset key - skip it (it's just a reference)
+    if (key === '$preset') {
+      continue;
+    }
+    
+    // If both are objects (not arrays), deep merge
+    if (isObject(userConfig[key]) && isObject(result[key])) {
+      result[key] = mergeConfig(result[key], userConfig[key]);
+    } else {
+      // Otherwise, user value replaces default
+      result[key] = deepClone(userConfig[key]);
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Merge preset with user config
+ * @param {Object} presetConfig - Preset configuration (e.g., typescript.yaml)
+ * @param {Object} defaultConfig - Default configuration
+ * @param {Object} userConfig - User configuration
+ * @returns {Object} Final merged configuration
+ */
+function mergeWithPreset(presetConfig, defaultConfig, userConfig) {
+  // First merge preset with defaults
+  let result = mergeConfig(defaultConfig, presetConfig || {});
+  
+  // Then merge user config
+  result = mergeConfig(result, userConfig || {});
+  
+  return result;
+}
+
+/**
+ * Validate merged configuration
+ * @param {Object} config - Merged configuration
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateMergedConfig(config) {
+  const errors = [];
+  
+  // Check required fields
+  if (!config.version) {
+    errors.push('Missing required field: version');
+  }
+  
+  if (!config.project) {
+    errors.push('Missing required field: project');
+  } else {
+    if (!config.project.name) {
+      errors.push('Missing required field: project.name');
+    }
+    if (!config.project.language) {
+      errors.push('Missing required field: project.language');
+    }
+  }
+  
+  // Validate agents
+  if (config.agents) {
+    const validAgents = ['planner', 'architect', 'developer', 'qa', 'reviewer', 'triage', 'ci_analyst'];
+    for (const agentName of Object.keys(config.agents)) {
+      if (!validAgents.includes(agentName)) {
+        errors.push(`Unknown agent: ${agentName}`);
+      }
+    }
+  }
+  
+  // Validate workflows
+  if (config.workflows) {
+    const validRoles = ['planner', 'architect', 'developer', 'qa', 'reviewer', 'triage', 'ci_analyst'];
+    for (const [workflowName, workflow] of Object.entries(config.workflows)) {
+      if (!workflow.sequence || !Array.isArray(workflow.sequence)) {
+        errors.push(`Workflow '${workflowName}' must have a sequence array`);
+      } else {
+        for (const role of workflow.sequence) {
+          if (!validRoles.includes(role)) {
+            errors.push(`Unknown role '${role}' in workflow '${workflowName}'`);
+          }
+        }
+      }
+    }
+  }
+  
+  // Validate rules
+  if (config.rules) {
+    if (config.rules.test_coverage_threshold !== undefined) {
+      const threshold = config.rules.test_coverage_threshold;
+      if (typeof threshold !== 'number' || threshold < 0 || threshold > 100) {
+        errors.push('test_coverage_threshold must be a number between 0 and 100');
+      }
+    }
+    
+    if (config.rules.max_function_lines !== undefined) {
+      const lines = config.rules.max_function_lines;
+      if (typeof lines !== 'number' || lines < 1) {
+        errors.push('max_function_lines must be a positive number');
+      }
+    }
+  }
+  
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+module.exports = {
+  mergeConfig,
+  mergeWithPreset,
+  validateMergedConfig,
+  deepClone,
+  isObject
+};

package/action/lib/path-resolver.js

@@ -0,0 +1,176 @@
+/**
+ * Path Resolver Module
+ * Resolves paths for skills, commands, memory, and tasks
+ * Handles cross-platform path resolution
+ */
+
+const path = require('path');
+
+/**
+ * Path Resolver Class
+ * Handles all path resolution for AmazingTeam Foundation
+ */
+class PathResolver {
+  /**
+   * @param {string} foundationDir - Path to downloaded foundation
+   * @param {string} projectDir - Path to user project
+   */
+  constructor(foundationDir, projectDir) {
+    this.foundationDir = foundationDir;
+    this.projectDir = projectDir;
+  }
+
+  /**
+   * Resolve a skill path (skills are in foundation)
+   * @param {string} relativePath - Relative path from foundation
+   * @returns {string} Absolute path to skill
+   */
+  resolveSkillPath(relativePath) {
+    return path.join(this.foundationDir, relativePath);
+  }
+
+  /**
+   * Resolve a command path (commands are in foundation)
+   * @param {string} relativePath - Relative path from foundation
+   * @returns {string} Absolute path to command
+   */
+  resolveCommandPath(relativePath) {
+    return path.join(this.foundationDir, relativePath);
+  }
+
+  /**
+   * Resolve memory path (memory is in user project - runtime state)
+   * @param {string} role - Agent role name
+   * @returns {string} Absolute path to role memory directory
+   */
+  resolveMemoryPath(role) {
+    return path.join(this.projectDir, '.amazingteam', 'memory', role);
+  }
+
+  /**
+   * Resolve failures library path
+   * @returns {string} Absolute path to failures directory
+   */
+  resolveFailuresPath() {
+    return path.join(this.projectDir, '.amazingteam', 'memory', 'failures');
+  }
+
+  /**
+   * Resolve task path
+   * @param {string|number} taskId - Issue ID
+   * @returns {string} Absolute path to task directory
+   */
+  resolveTaskPath(taskId) {
+    return path.join(this.projectDir, 'tasks', `issue-${taskId}`);
+  }
+
+  /**
+   * Resolve task template path
+   * @returns {string} Absolute path to task template directory
+   */
+  resolveTaskTemplatePath() {
+    return path.join(this.projectDir, 'tasks', '_template');
+  }
+
+  /**
+   * Resolve AGENTS.md path (from foundation, but user can override)
+   * @param {boolean} userOverride - Whether user has local AGENTS.md
+   * @returns {string} Path to AGENTS.md
+   */
+  resolveAgentsPath(userOverride = false) {
+    if (userOverride) {
+      return path.join(this.projectDir, 'AGENTS.md');
+    }
+    return path.join(this.foundationDir, 'AGENTS.md');
+  }
+
+  /**
+   * Resolve OpenCode config path (in user project)
+   * @returns {string} Absolute path to opencode.jsonc
+   */
+  resolveOpenCodeConfigPath() {
+    return path.join(this.projectDir, 'opencode.jsonc');
+  }
+
+  /**
+   * Resolve user config path
+   * @param {string} configPath - Config file name (default: amazingteam.config.yaml)
+   * @returns {string} Absolute path to user config
+   */
+  resolveUserConfigPath(configPath = 'amazingteam.config.yaml') {
+    return path.join(this.projectDir, configPath);
+  }
+
+  /**
+   * Get all memory directories that need to be created
+   * @returns {string[]} Array of memory directory paths
+   */
+  getMemoryDirectories() {
+    const roles = ['planner', 'architect', 'developer', 'qa', 'reviewer', 'triage', 'ci-analyst'];
+    return roles.map(role => this.resolveMemoryPath(role));
+  }
+
+  /**
+   * Get all runtime directories that need to exist
+   * @returns {string[]} Array of directory paths
+   */
+  getRuntimeDirectories() {
+    return [
+      ...this.getMemoryDirectories(),
+      this.resolveFailuresPath(),
+      this.resolveTaskTemplatePath(),
+      path.join(this.projectDir, '.amazingteam'),
+      path.join(this.projectDir, 'tasks')
+    ];
+  }
+
+  /**
+   * Get foundation skills directory
+   * @returns {string} Path to foundation .opencode/skills
+   */
+  getFoundationSkillsDir() {
+    return path.join(this.foundationDir, '.opencode', 'skills');
+  }
+
+  /**
+   * Get foundation commands directory
+   * @returns {string} Path to foundation .amazingteam/commands
+   */
+  getFoundationCommandsDir() {
+    return path.join(this.foundationDir, '.amazingteam', 'commands');
+  }
+
+  /**
+   * Get foundation agents directory
+   * @returns {string} Path to foundation .amazingteam/agents
+   */
+  getFoundationAgentsDir() {
+    return path.join(this.foundationDir, '.amazingteam', 'agents');
+  }
+
+  /**
+   * Resolve template variables in a string
+   * @param {string} str - String with template variables
+   * @param {Object} vars - Variables to substitute
+   * @returns {string} Resolved string
+   */
+  resolveTemplateVars(str, vars) {
+    let result = str;
+    for (const [key, value] of Object.entries(vars)) {
+      const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+      result = result.replace(regex, value);
+    }
+    return result;
+  }
+
+  /**
+   * Normalize path for cross-platform compatibility
+   * @param {string} p - Path to normalize
+   * @returns {string} Normalized path
+   */
+  static normalize(p) {
+    return path.normalize(p).replace(/\\/g, '/');
+  }
+}
+
+module.exports = PathResolver;