amazingteam 3.0.0

package/cli/commands/init.cjs

@@ -0,0 +1,412 @@
+/**
+ * Init Command
+ * Initialize AmazingTeam in a project
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const VERSION = require('../../package.json').version;
+
+const COLORS = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${COLORS[color] || ''}${message}${COLORS.reset}`);
+}
+
+function createRL() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+function question(rl, prompt, defaultValue = null) {
+  return new Promise(resolve => {
+    const displayPrompt = defaultValue 
+      ? `${prompt} (${defaultValue}): `
+      : `${prompt}: `;
+    rl.question(displayPrompt, answer => {
+      resolve(answer || defaultValue);
+    });
+  });
+}
+
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function getTemplate(name) {
+  const templates = {
+    'amazingteam.config.yaml': `# AmazingTeam Project Configuration
+# Generated by amazingteam init
+
+version: "1.0"
+
+project:
+  name: "{{PROJECT_NAME}}"
+  description: "{{PROJECT_DESCRIPTION}}"
+  language: "{{LANGUAGE}}"
+  framework: "{{FRAMEWORK}}"
+
+ai_team:
+  version: "{{AI_TEAM_VERSION}}"
+
+build:
+  command: "{{BUILD_COMMAND}}"
+  test: "{{TEST_COMMAND}}"
+  lint: "{{LINT_COMMAND}}"
+
+# Uncomment to use an overlay:
+# overlay: "{{OVERLAY}}"
+
+# Custom rules (optional)
+rules:
+  test_coverage_threshold: 80
+  max_function_lines: 30
+`,
+
+    'opencode.jsonc': `{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "default",
+  "small_model": "default",
+  "default_agent": "build",
+  "instructions": ["AGENTS.md"],
+  "autoupdate": true,
+  "permission": {
+    "edit": "ask",
+    "bash": "ask"
+  },
+  "tools": {
+    "write": true,
+    "edit": true,
+    "bash": true
+  }
+}
+`,
+
+    'gitignore_additions': `
+# AmazingTeam local foundation (downloaded by \`amazingteam local\`)
+.ai-team-local/
+
+# AmazingTeam cache
+.ai-team-cache/
+`
+  };
+  
+  return templates[name] || '';
+}
+
+function getWorkflowTemplate(version) {
+  return `# AmazingTeam GitHub Action Workflow
+# This workflow enables AI-powered development in your repository
+
+name: AmazingTeam
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+
+jobs:
+  ai-team:
+    if: |
+      startsWith(github.event.comment.body, '/ai') ||
+      startsWith(github.event.comment.body, '/opencode') ||
+      startsWith(github.event.comment.body, '/oc')
+    
+    runs-on: ubuntu-latest
+    
+    permissions:
+      id-token: write
+      contents: write
+      pull-requests: write
+      issues: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure git
+        run: |
+          git config --global user.name "opencode-bot"
+          git config --global user.email "opencode-bot@users.noreply.github.com"
+
+      - name: Setup AmazingTeam
+        uses: your-org/amazingteam-action@v${version}
+        with:
+          version: '${version}'
+          config: 'amazingteam.config.yaml'
+
+      - name: Run OpenCode
+        uses: anomalyco/opencode/github@latest
+        env:
+          ALIBABA_CODING_PLAN_API_KEY: \${{ secrets.ALIBABA_CODING_PLAN_API_KEY }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        with:
+          model: alibaba-coding-plan/glm-5
+`;
+}
+
+function getLanguageDefaults(language) {
+  const defaults = {
+    typescript: {
+      framework: 'node',
+      buildCommand: 'npm run build',
+      testCommand: 'npm test',
+      lintCommand: 'npm run lint'
+    },
+    javascript: {
+      framework: 'node',
+      buildCommand: 'npm run build',
+      testCommand: 'npm test',
+      lintCommand: 'npm run lint'
+    },
+    python: {
+      framework: 'fastapi',
+      buildCommand: 'python -m build',
+      testCommand: 'pytest',
+      lintCommand: 'ruff check .'
+    },
+    go: {
+      framework: 'gin',
+      buildCommand: 'go build ./...',
+      testCommand: 'go test ./...',
+      lintCommand: 'golangci-lint run'
+    },
+    java: {
+      framework: 'spring',
+      buildCommand: './mvnw package',
+      testCommand: './mvnw test',
+      lintCommand: './mvnw checkstyle:check'
+    },
+    cpp: {
+      framework: 'qt',
+      buildCommand: 'cmake --build build',
+      testCommand: 'ctest --test-dir build',
+      lintCommand: 'clang-tidy'
+    },
+    rust: {
+      framework: 'cargo',
+      buildCommand: 'cargo build',
+      testCommand: 'cargo test',
+      lintCommand: 'cargo clippy'
+    }
+  };
+  
+  return defaults[language] || defaults.typescript;
+}
+
+async function run(options, positional) {
+  const rl = createRL();
+  
+  try {
+    log('\n🚀 AmazingTeam Foundation Initializer\n', 'cyan');
+    
+    const projectPath = process.cwd();
+    const projectName = positional[0] || path.basename(projectPath);
+    
+    // Check if already initialized
+    const configPath = path.join(projectPath, 'amazingteam.config.yaml');
+    if (fileExists(configPath) && !options.force) {
+      log('⚠️  AmazingTeam already initialized in this directory.', 'yellow');
+      log('   Use --force to reinitialize.\n');
+      rl.close();
+      return;
+    }
+    
+    // Interactive prompts or use options
+    let language = options.language;
+    let framework = options.framework;
+    let description = options.description;
+    let overlay = options.overlay;
+    
+    if (!options.language) {
+      language = await question(rl, 'Language', 'typescript');
+    }
+    
+    if (!options.framework) {
+      const defaultFramework = getLanguageDefaults(language).framework;
+      framework = await question(rl, 'Framework', defaultFramework);
+    }
+    
+    if (!options.description) {
+      description = await question(rl, 'Description', 'My awesome project');
+    }
+    
+    if (!options.overlay && options.overlay !== null) {
+      const overlayAnswer = await question(rl, 'Overlay (leave empty for none)', '');
+      overlay = overlayAnswer || null;
+    }
+    
+    const langDefaults = getLanguageDefaults(language);
+    
+    log('\n📦 Creating project structure...', 'blue');
+    
+    // Create directories
+    const dirs = [
+      '.ai-team/memory/planner',
+      '.ai-team/memory/architect',
+      '.ai-team/memory/developer',
+      '.ai-team/memory/qa',
+      '.ai-team/memory/reviewer',
+      '.ai-team/memory/triage',
+      '.ai-team/memory/ci-analyst',
+      '.ai-team/memory/failures',
+      '.github/workflows',
+      'tasks/_template',
+      'src'
+    ];
+    
+    for (const dir of dirs) {
+      const fullPath = path.join(projectPath, dir);
+      if (!fileExists(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+      }
+    }
+    
+    log('📝 Creating configuration files...', 'blue');
+    
+    // Generate amazingteam.config.yaml
+    let configContent = getTemplate('amazingteam.config.yaml');
+    configContent = configContent
+      .replace(/\{\{PROJECT_NAME\}\}/g, projectName)
+      .replace(/\{\{PROJECT_DESCRIPTION\}\}/g, description)
+      .replace(/\{\{LANGUAGE\}\}/g, language)
+      .replace(/\{\{FRAMEWORK\}\}/g, framework)
+      .replace(/\{\{AI_TEAM_VERSION\}\}/g, VERSION)
+      .replace(/\{\{BUILD_COMMAND\}\}/g, langDefaults.buildCommand)
+      .replace(/\{\{TEST_COMMAND\}\}/g, langDefaults.testCommand)
+      .replace(/\{\{LINT_COMMAND\}\}/g, langDefaults.lintCommand)
+      .replace(/\{\{OVERLAY\}\}/g, overlay || '');
+    
+    fs.writeFileSync(configPath, configContent);
+    
+    // Generate opencode.jsonc
+    const opencodePath = path.join(projectPath, 'opencode.jsonc');
+    fs.writeFileSync(opencodePath, getTemplate('opencode.jsonc'));
+    
+    // Generate workflow
+    const workflowPath = path.join(projectPath, '.github', 'workflows', 'amazingteam.yml');
+    fs.writeFileSync(workflowPath, getWorkflowTemplate(VERSION));
+    
+    // Update .gitignore
+    log('📝 Updating .gitignore...', 'blue');
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    let gitignoreContent = '';
+    
+    if (fileExists(gitignorePath)) {
+      gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+      if (!gitignoreContent.includes('.ai-team-local/')) {
+        gitignoreContent += getTemplate('gitignore_additions');
+        fs.writeFileSync(gitignorePath, gitignoreContent);
+      }
+    } else {
+      fs.writeFileSync(gitignorePath, getTemplate('gitignore_additions').trim() + '\n');
+    }
+    
+    // Create placeholder memory files
+    log('📋 Creating memory placeholders...', 'blue');
+    const memoryFiles = {
+      'planner': ['decomposition_notes.md', 'flow_rules.md'],
+      'architect': ['architecture_notes.md', 'module_map.md'],
+      'developer': ['implementation_notes.md', 'bug_investigation.md'],
+      'qa': ['test_strategy.md', 'validation_notes.md'],
+      'reviewer': ['review_notes.md', 'quality_rules.md'],
+      'triage': ['classification_heuristics.md', 'debug_notes.md'],
+      'ci-analyst': ['failure_patterns.md', 'runbook_references.md'],
+      'failures': ['failure_library.md']
+    };
+    
+    for (const [role, files] of Object.entries(memoryFiles)) {
+      for (const file of files) {
+        const filePath = path.join(projectPath, '.ai-team', 'memory', role, file);
+        if (!fileExists(filePath)) {
+          fs.writeFileSync(filePath, `# ${role} ${file.replace('.md', '').replace(/_/g, ' ')}\n\n`);
+        }
+      }
+    }
+    
+    // Create task template
+    const taskTemplatePath = path.join(projectPath, 'tasks', '_template', 'task.yaml');
+    if (!fileExists(taskTemplatePath)) {
+      fs.writeFileSync(taskTemplatePath, `id: template
+title: Task Title
+type: feature
+status: backlog
+priority: medium
+owner_role: developer
+depends_on: []
+blocked_by: []
+acceptance_criteria: []
+risk_level: low
+module_scope: []
+`);
+    }
+    
+    log('\n✅ AmazingTeam initialized successfully!\n', 'green');
+    
+    log('Next steps:', 'cyan');
+    log('  1. Review and customize amazingteam.config.yaml');
+    log('  2. Add your GitHub secrets:');
+    log('     - ALIBABA_CODING_PLAN_API_KEY or OPENCODE_API_KEY');
+    log('  3. Run `amazingteam local` for local development');
+    log('  4. Create your first issue!\n');
+    
+    log('Configuration:', 'cyan');
+    log(`  Project: ${projectName}`);
+    log(`  Language: ${language}`);
+    log(`  Framework: ${framework}`);
+    log(`  Version: ${VERSION}`);
+    if (overlay) {
+      log(`  Overlay: ${overlay}`);
+    }
+    log('');
+    
+  } finally {
+    rl.close();
+  }
+}
+
+function help() {
+  return `
+${COLORS.cyan}amazingteam init${COLORS.reset} - Initialize AmazingTeam in a project
+
+${COLORS.yellow}Usage:${COLORS.reset}
+  amazingteam init [project-name] [options]
+
+${COLORS.yellow}Options:${COLORS.reset}
+  --language, -l <lang>    Programming language (default: typescript)
+  --framework <fw>         Framework (default: based on language)
+  --overlay, -o <name>     Apply overlay (python-backend, web-fullstack, etc.)
+  --description, -d <desc> Project description
+  --force                  Force reinitialization
+
+${COLORS.yellow}Examples:${COLORS.reset}
+  amazingteam init                              Interactive initialization
+  amazingteam init my-project                   Create project with defaults
+  amazingteam init -l python -o python-backend  Python with overlay
+  amazingteam init --force                      Reinitialize existing project
+
+${COLORS.yellow}Created Files:${COLORS.reset}
+  amazingteam.config.yaml      Project configuration
+  opencode.jsonc           OpenCode configuration
+  .github/workflows/amazingteam.yml   GitHub Action workflow
+  .ai-team/memory/         Role memory directories
+  tasks/_template/         Task template directory
+`;
+}
+
+module.exports = { run, help };

package/cli/commands/local.cjs

@@ -0,0 +1,264 @@
+/**
+ * Local Command
+ * Download foundation for local development
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const VERSION = require('../../package.json').version;
+const PACKAGE_NAME = 'amazingteam';
+const REGISTRY = 'https://registry.npmjs.org';
+const CACHE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.ai-team-cache');
+const LOCAL_DIR = '.ai-team-local';
+
+function downloadFromNpm(version, destDir) {
+  const url = `${REGISTRY}/${PACKAGE_NAME}/-/${PACKAGE_NAME}-${version}.tgz`;
+  const tarballPath = path.join(destDir, `${PACKAGE_NAME}-${version}.tgz`);
+  
+  console.log(`Downloading from NPM: ${url}`);
+  
+  try {
+    execSync(`curl -L -o "${tarballPath}" "${url}"`, { stdio: 'inherit' });
+  } catch (err) {
+    throw new Error(`Failed to download: ${err.message}`);
+  }
+  
+  return tarballPath;
+}
+
+function extractTarball(tarballPath, destDir) {
+  console.log('Extracting...');
+  
+  try {
+    execSync(`tar -xzf "${tarballPath}" -C "${destDir}"`, { stdio: 'inherit' });
+  } catch (err) {
+    throw new Error(`Failed to extract: ${err.message}`);
+  }
+}
+
+function readConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  
+  const content = fs.readFileSync(configPath, 'utf-8');
+  const config = {};
+  
+  content.split('\n').forEach(line => {
+    const match = line.match(/^(\w+):\s*["']?([^"'\n]+)["']?/);
+    if (match) {
+      config[match[1]] = match[2];
+    }
+    
+    const nestedMatch = line.match(/^  (\w+):\s*["']?([^"'\n]+)["']?/);
+    if (nestedMatch) {
+      const parent = line.split('  ')[0]?.match(/^(\w+):/)?.[1];
+      if (parent && !config[parent]) {
+        config[parent] = {};
+      }
+      if (config[parent]) {
+        config[parent][nestedMatch[1]] = nestedMatch[2];
+      }
+    }
+  });
+  
+  return config;
+}
+
+function generateLocalOpenCodeConfig(projectDir, foundationDir, config) {
+  return `{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "default",
+  "small_model": "default",
+  "default_agent": "build",
+  "instructions": [
+    "${foundationDir}/AGENTS.md",
+    "AGENTS.md"
+  ],
+  "autoupdate": true,
+  "permission": {
+    "edit": "ask",
+    "bash": "ask"
+  },
+  "tools": {
+    "write": true,
+    "edit": true,
+    "bash": true
+  },
+  "skills": {
+    "test-first-feature-dev": {
+      "path": "${foundationDir}/.opencode/skills/test-first-feature-dev/SKILL.md"
+    },
+    "bugfix-playbook": {
+      "path": "${foundationDir}/.opencode/skills/bugfix-playbook/SKILL.md"
+    },
+    "repo-architecture-reader": {
+      "path": "${foundationDir}/.opencode/skills/repo-architecture-reader/SKILL.md"
+    },
+    "task-breakdown-and-dispatch": {
+      "path": "${foundationDir}/.opencode/skills/task-breakdown-and-dispatch/SKILL.md"
+    }
+  }
+}`;
+}
+
+async function run(options, positional) {
+  const projectPath = process.cwd();
+  const configPath = path.join(projectPath, 'amazingteam.config.yaml');
+  const localPath = path.join(projectPath, LOCAL_DIR);
+  
+  console.log('\n📥 Downloading AmazingTeam Foundation for local use\n');
+  
+  // Check if initialized
+  if (!fs.existsSync(configPath)) {
+    console.error('❌ AmazingTeam not initialized in this directory.');
+    console.error('   Run "amazingteam init" first.\n');
+    process.exit(1);
+  }
+  
+  // Read config
+  const config = readConfig(configPath);
+  const targetVersion = config?.ai_team?.version || VERSION;
+  
+  console.log(`Target version: ${targetVersion}`);
+  
+  // Check if using local path
+  if (options.from) {
+    const fromPath = path.resolve(options.from);
+    
+    if (!fs.existsSync(fromPath)) {
+      console.error(`❌ Local path not found: ${fromPath}\n`);
+      process.exit(1);
+    }
+    
+    console.log(`Using local foundation: ${fromPath}`);
+    
+    // Create symlink or copy
+    if (fs.existsSync(localPath)) {
+      fs.rmSync(localPath, { recursive: true });
+    }
+    
+    // Copy instead of symlink for reliability
+    console.log('Copying foundation files...');
+    fs.cpSync(fromPath, localPath, { recursive: true });
+    
+    console.log(`\n✅ Foundation copied to ${LOCAL_DIR}/\n`);
+  } else {
+    // Download from NPM
+    console.log('Downloading from NPM...\n');
+    
+    // Create cache directory
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    
+    // Check cache
+    const cachedPath = path.join(CACHE_DIR, `v${targetVersion}`);
+    
+    if (fs.existsSync(cachedPath) && !options.force) {
+      console.log(`Using cached version: ${cachedPath}`);
+    } else {
+      // Download
+      const tempDir = path.join(CACHE_DIR, 'temp');
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+      
+      try {
+        const tarballPath = downloadFromNpm(targetVersion, tempDir);
+        extractTarball(tarballPath, tempDir);
+        
+        // Move to cache
+        const extractedPath = path.join(tempDir, 'package');
+        if (fs.existsSync(cachedPath)) {
+          fs.rmSync(cachedPath, { recursive: true });
+        }
+        fs.renameSync(extractedPath, cachedPath);
+        
+        // Cleanup
+        fs.unlinkSync(tarballPath);
+        fs.rmSync(tempDir, { recursive: true });
+        
+        console.log('✅ Download complete');
+      } catch (error) {
+        console.error('❌ Download failed:', error.message);
+        console.log('\nAlternatives:');
+        console.log('  - Check your network connection');
+        console.log('  - Use --from /path/to/local/foundation for offline mode');
+        console.log('');
+        process.exit(1);
+      }
+    }
+    
+    // Copy to local directory
+    console.log(`\nCopying to ${LOCAL_DIR}/...`);
+    
+    if (fs.existsSync(localPath)) {
+      fs.rmSync(localPath, { recursive: true });
+    }
+    
+    fs.cpSync(cachedPath, localPath, { recursive: true });
+    
+    console.log('✅ Copy complete');
+  }
+  
+  // Generate local opencode.jsonc
+  console.log('\n📝 Generating opencode.jsonc for local development...');
+  
+  const opencodeContent = generateLocalOpenCodeConfig(projectPath, localPath, config);
+  const opencodePath = path.join(projectPath, 'opencode.jsonc');
+  
+  // Backup existing if different
+  if (fs.existsSync(opencodePath)) {
+    const existing = fs.readFileSync(opencodePath, 'utf-8');
+    if (existing !== opencodeContent) {
+      fs.writeFileSync(opencodePath + '.backup', existing);
+      console.log('  (Backed up existing opencode.jsonc)');
+    }
+  }
+  
+  fs.writeFileSync(opencodePath, opencodeContent);
+  console.log('✅ Generated opencode.jsonc');
+  
+  // Summary
+  console.log('\n🎉 Local setup complete!\n');
+  console.log('Foundation files:', LOCAL_DIR);
+  console.log('OpenCode config: opencode.jsonc');
+  console.log('\nYou can now use OpenCode locally with full AmazingTeam capabilities.\n');
+  
+  // Update .gitignore reminder
+  console.log('Reminder: Add .ai-team-local/ to .gitignore if not already done.');
+  console.log('');
+}
+
+function help() {
+  return `
+amazingteam local - Download foundation for local development
+
+Usage:
+  amazingteam local [options]
+
+Options:
+  --from <path>     Use local foundation path (offline mode)
+  --force           Force re-download even if cached
+
+Examples:
+  amazingteam local                     Download from NPM
+  amazingteam local --from ../foundation   Use local copy
+  amazingteam local --force              Force re-download
+
+What it does:
+  1. Downloads AmazingTeam Foundation to .ai-team-local/
+  2. Generates opencode.jsonc with local paths
+  3. Caches downloads in ~/.ai-team-cache/
+
+The local foundation allows you to use OpenCode locally
+with all AmazingTeam skills and configurations.
+
+Note: .ai-team-local/ should be in .gitignore.
+`;
+}
+
+module.exports = { run, help };