create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/generate-greeting.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Unified Greeting Generator - CLI Wrapper
+ *
+ * Story ACT-6: Refactored as thin wrapper around ActivationRuntime.
+ *
+ * ARCHITECTURE NOTE:
+ * This file is now a thin CLI wrapper that delegates to the
+ * ActivationRuntime for all context loading and greeting generation.
+ * Previously, this file orchestrated its own parallel loading of
+ * AgentConfigLoader, SessionContextLoader, and ProjectStatusLoader.
+ * Now ALL agents (not just 3) can use the same unified pipeline.
+ *
+ * Performance Targets:
+ * - With cache: <50ms
+ * - Without cache: <200ms (timeout protection in pipeline)
+ * - Fallback: <10ms
+ *
+ * Usage: node generate-greeting.js <agent-id>
+ *
+ * Used by: @devops, @data-engineer, @ux-design-expert (CLI invocation pattern)
+ * Note: All 12 agents now activate through ActivationRuntime.
+ *
+ * @see activation-runtime.js for the runtime entrypoint
+ * @see unified-activation-pipeline.js for pipeline internals
+ * @see greeting-builder.js for core greeting logic
+ *
+ * Part of Story 6.1.4: Unified Greeting System Integration
+ * Part of Story ACT-6: Unified Activation Pipeline
+ */
+
+'use strict';
+
+const { ActivationRuntime } = require('./activation-runtime');
+
+/**
+ * Generate unified greeting for agent activation.
+ *
+ * Delegates to ActivationRuntime.activate() which handles:
+ * - Parallel loading of config, session, project status, git, permissions
+ * - Sequential context detection and workflow state
+ * - Greeting generation via GreetingBuilder
+ *
+ * @param {string} agentId - Agent identifier (e.g., 'qa', 'dev')
+ * @returns {Promise<string>} Formatted greeting string
+ *
+ * @example
+ * const greeting = await generateGreeting('qa');
+ * console.log(greeting);
+ */
+async function generateGreeting(agentId) {
+  try {
+    const runtime = new ActivationRuntime();
+    const result = await runtime.activate(agentId);
+
+    if (result.duration > 100) {
+      console.warn(`[generate-greeting] Slow generation: ${result.duration}ms`);
+    }
+
+    return result.greeting;
+
+  } catch (error) {
+    console.error('[generate-greeting] Error:', {
+      agentId,
+      error: error.message,
+      stack: error.stack,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Fallback: Simple greeting
+    return generateFallbackGreeting(agentId);
+  }
+}
+
+/**
+ * Generate fallback greeting if everything fails
+ * @private
+ * @param {string} agentId - Agent ID
+ * @returns {string} Simple fallback greeting
+ */
+function generateFallbackGreeting(agentId) {
+  return `\u2705 ${agentId} Agent ready\n\nType \`*help\` to see available commands.`;
+}
+
+// CLI interface
+if (require.main === module) {
+  const agentId = process.argv[2];
+
+  if (!agentId) {
+    console.error('Usage: node generate-greeting.js <agent-id>');
+    console.error('\nExamples:');
+    console.error('  node generate-greeting.js qa');
+    console.error('  node generate-greeting.js dev');
+    process.exit(1);
+  }
+
+  generateGreeting(agentId)
+    .then(greeting => {
+      console.log(greeting);
+      process.exit(0);
+    })
+    .catch(error => {
+      console.error('Fatal error:', error.message);
+      console.log(generateFallbackGreeting(agentId));
+      process.exit(1);
+    });
+}
+
+module.exports = { generateGreeting };

package/template/.aiox-core/development/scripts/git-wrapper.js

@@ -0,0 +1,462 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+const _path = require('path');
+const _fs = require('fs').promises;
+const chalk = require('chalk');
+
+/**
+ * Git operations wrapper for AIOX framework modifications
+ */
+class GitWrapper {
+  constructor(options = {}) {
+    this.rootPath = options.rootPath || process.cwd();
+    this.gitPath = options.gitPath || 'git';
+    this.defaultBranch = options.defaultBranch || 'main';
+    this.metaAgentPrefix = options.metaAgentPrefix || 'meta-agent/';
+  }
+
+  /**
+   * Execute a git command
+   * @private
+   */
+  async execGit(command, options = {}) {
+    try {
+      const { stdout, stderr } = await execAsync(`${this.gitPath} ${command}`, {
+        cwd: this.rootPath,
+        ...options
+      });
+      
+      if (stderr && !options.ignoreStderr) {
+        console.warn(chalk.yellow(`Git warning: ${stderr}`));
+      }
+      
+      return stdout.trim();
+    } catch (_error) {
+      throw new Error(`Git command failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if git is initialized
+   * @returns {Promise<boolean>}
+   */
+  async isGitInitialized() {
+    try {
+      await this.execGit('status');
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  /**
+   * Initialize git repository if not already initialized
+   * @returns {Promise<void>}
+   */
+  async initializeRepository() {
+    const initialized = await this.isGitInitialized();
+    if (!initialized) {
+      await this.execGit('init');
+      console.log(chalk.green('✅ Git repository initialized'));
+    }
+  }
+
+  /**
+   * Get current branch name
+   * @returns {Promise<string>}
+   */
+  async getCurrentBranch() {
+    return await this.execGit('rev-parse --abbrev-ref HEAD');
+  }
+
+  /**
+   * Create a new branch
+   * @param {string} branchName - Name of the branch to create
+   * @param {boolean} checkout - Whether to checkout the branch
+   * @returns {Promise<void>}
+   */
+  async createBranch(branchName, checkout = true) {
+    try {
+      if (checkout) {
+        await this.execGit(`checkout -b ${branchName}`);
+      } else {
+        await this.execGit(`branch ${branchName}`);
+      }
+      console.log(chalk.green(`✅ Created branch: ${branchName}`));
+    } catch (_error) {
+      // Branch might already exist
+      if (error.message.includes('already exists')) {
+        console.log(chalk.yellow(`Branch already exists: ${branchName}`));
+        if (checkout) {
+          await this.checkoutBranch(branchName);
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Checkout an existing branch
+   * @param {string} branchName - Name of the branch to checkout
+   * @returns {Promise<void>}
+   */
+  async checkoutBranch(branchName) {
+    await this.execGit(`checkout ${branchName}`);
+    console.log(chalk.green(`✅ Checked out branch: ${branchName}`));
+  }
+
+  /**
+   * Create a branch for meta-agent modifications
+   * @param {string} modificationName - Name of the modification
+   * @returns {Promise<string>} Branch name
+   */
+  async createModificationBranch(modificationName) {
+    const timestamp = new Date().toISOString().substring(0, 10);
+    const branchName = `${this.metaAgentPrefix}${modificationName}-${timestamp}`;
+    await this.createBranch(branchName);
+    return branchName;
+  }
+
+  /**
+   * Stage files for commit
+   * @param {Array<string>} files - Files to stage
+   * @returns {Promise<void>}
+   */
+  async stageFiles(files) {
+    if (!Array.isArray(files) || files.length === 0) {
+      throw new Error('No files provided to stage');
+    }
+
+    for (const file of files) {
+      await this.execGit(`add "${file}"`);
+    }
+    
+    console.log(chalk.green(`✅ Staged ${files.length} files`));
+  }
+
+  /**
+   * Commit changes with message
+   * @param {string} message - Commit message
+   * @param {Object} options - Commit options
+   * @returns {Promise<string>} Commit hash
+   */
+  async commit(message, options = {}) {
+    const {
+      author = 'aiox-developer <aiox-developer@aiox-fullstack.local>',
+      signoff = true
+    } = options;
+
+    let command = `commit -m "${message.replace(/"/g, '\\"')}"`;
+    
+    if (author) {
+      command += ` --author="${author}"`;
+    }
+    
+    if (signoff) {
+      command += ' --signoff';
+    }
+
+    const output = await this.execGit(command);
+    const hashMatch = output.match(/\[[\w-]+ ([\w]+)\]/);
+    const commitHash = hashMatch ? hashMatch[1] : 'unknown';
+    
+    console.log(chalk.green(`✅ Committed: ${commitHash}`));
+    return commitHash;
+  }
+
+  /**
+   * Create a commit for component modifications
+   * @param {Array<string>} files - Files to commit
+   * @param {string} message - Commit message
+   * @param {Object} metadata - Additional metadata
+   * @returns {Promise<string>} Commit hash
+   */
+  async commitModification(files, message, metadata = {}) {
+    await this.stageFiles(files);
+    
+    // Add metadata to commit message
+    let fullMessage = message;
+    if (metadata.componentType && metadata.componentName) {
+      fullMessage = `${metadata.componentType}(${metadata.componentName}): ${message}`;
+    }
+    
+    if (metadata.breakingChange) {
+      fullMessage += '\n\nBREAKING CHANGE: ' + metadata.breakingChange;
+    }
+    
+    if (metadata.approvedBy) {
+      fullMessage += `\n\nApproved-by: ${metadata.approvedBy}`;
+    }
+    
+    fullMessage += '\n\nGenerated by: aiox-developer meta-agent';
+    
+    return await this.commit(fullMessage);
+  }
+
+  /**
+   * Get git status
+   * @returns {Promise<Object>} Status information
+   */
+  async getStatus() {
+    const porcelainStatus = await this.execGit('status --porcelain');
+    const branch = await this.getCurrentBranch();
+    
+    const files = {
+      modified: [],
+      added: [],
+      deleted: [],
+      untracked: []
+    };
+    
+    if (porcelainStatus) {
+      const lines = porcelainStatus.split('\n');
+      for (const line of lines) {
+        if (!line) continue;
+        
+        const status = line.substring(0, 2);
+        const filename = line.substring(3);
+        
+        if (status.includes('M')) files.modified.push(filename);
+        else if (status.includes('A')) files.added.push(filename);
+        else if (status.includes('D')) files.deleted.push(filename);
+        else if (status === '??') files.untracked.push(filename);
+      }
+    }
+    
+    return {
+      branch,
+      clean: porcelainStatus === '',
+      files
+    };
+  }
+
+  /**
+   * Get commit history
+   * @param {number} limit - Number of commits to retrieve
+   * @returns {Promise<Array>} Commit history
+   */
+  async getHistory(limit = 10) {
+    const format = '%H|%an|%ae|%at|%s';
+    const output = await this.execGit(`log -${limit} --format="${format}"`);
+    
+    if (!output) return [];
+    
+    return output.split('\n').map(line => {
+      const [hash, author, email, timestamp, subject] = line.split('|');
+      return {
+        hash,
+        author,
+        email,
+        date: new Date(parseInt(timestamp) * 1000),
+        subject
+      };
+    });
+  }
+
+  /**
+   * Check for conflicts
+   * @returns {Promise<Array>} List of conflicted files
+   */
+  async getConflicts() {
+    try {
+      const output = await this.execGit('diff --name-only --diff-filter=U');
+      return output ? output.split('\n').filter(Boolean) : [];
+    } catch (_error) {
+      return [];
+    }
+  }
+
+  /**
+   * Merge a branch
+   * @param {string} branchName - Branch to merge
+   * @param {Object} options - Merge options
+   * @returns {Promise<Object>} Merge result
+   */
+  async mergeBranch(branchName, options = {}) {
+    const {
+      strategy = 'recursive',
+      message = null,
+      noFastForward = true
+    } = options;
+
+    let command = `merge ${branchName}`;
+    
+    if (strategy) {
+      command += ` --strategy=${strategy}`;
+    }
+    
+    if (noFastForward) {
+      command += ' --no-ff';
+    }
+    
+    if (message) {
+      command += ` -m "${message.replace(/"/g, '\\"')}"`;
+    }
+
+    try {
+      const output = await this.execGit(command);
+      return {
+        success: true,
+        message: output
+      };
+    } catch (_error) {
+      // Check for conflicts
+      const conflicts = await this.getConflicts();
+      if (conflicts.length > 0) {
+        return {
+          success: false,
+          conflicts,
+          error: 'Merge conflicts detected'
+        };
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Create a tag
+   * @param {string} tagName - Name of the tag
+   * @param {string} message - Tag message
+   * @returns {Promise<void>}
+   */
+  async createTag(tagName, message) {
+    await this.execGit(`tag -a ${tagName} -m "${message.replace(/"/g, '\\"')}"`);
+    console.log(chalk.green(`✅ Created tag: ${tagName}`));
+  }
+
+  /**
+   * Push changes to remote
+   * @param {string} remote - Remote name
+   * @param {string} branch - Branch name
+   * @param {Object} options - Push options
+   * @returns {Promise<void>}
+   */
+  async push(remote = 'origin', branch = null, options = {}) {
+    const currentBranch = branch || await this.getCurrentBranch();
+    let command = `push ${remote} ${currentBranch}`;
+    
+    if (options.tags) {
+      command += ' --tags';
+    }
+    
+    if (options.force) {
+      command += ' --force';
+    }
+    
+    if (options.setUpstream) {
+      command = `push -u ${remote} ${currentBranch}`;
+    }
+
+    await this.execGit(command);
+    console.log(chalk.green(`✅ Pushed to ${remote}/${currentBranch}`));
+  }
+
+  /**
+   * Get diff between commits or working tree
+   * @param {Object} options - Diff options
+   * @returns {Promise<string>} Diff output
+   */
+  async getDiff(options = {}) {
+    const {
+      from = 'HEAD',
+      to = null,
+      files = [],
+      nameOnly = false
+    } = options;
+
+    let command = 'diff';
+    
+    if (nameOnly) {
+      command += ' --name-only';
+    }
+    
+    if (to) {
+      command += ` ${from} ${to}`;
+    } else {
+      command += ` ${from}`;
+    }
+    
+    if (files.length > 0) {
+      command += ` -- ${files.join(' ')}`;
+    }
+
+    return await this.execGit(command);
+  }
+
+  /**
+   * Stash changes
+   * @param {string} message - Stash message
+   * @returns {Promise<void>}
+   */
+  async stash(message = 'Meta-agent modifications') {
+    await this.execGit(`stash push -m "${message}"`);
+    console.log(chalk.green('✅ Changes stashed'));
+  }
+
+  /**
+   * Apply stash
+   * @param {string} stashRef - Stash reference
+   * @returns {Promise<void>}
+   */
+  async stashApply(stashRef = 'stash@{0}') {
+    await this.execGit(`stash apply ${stashRef}`);
+    console.log(chalk.green('✅ Stash applied'));
+  }
+
+  /**
+   * Get remote information
+   * @returns {Promise<Array>} Remote information
+   */
+  async getRemotes() {
+    const output = await this.execGit('remote -v');
+    if (!output) return [];
+
+    const remotes = {};
+    output.split('\n').forEach(line => {
+      const [name, url, type] = line.split(/\s+/);
+      if (!remotes[name]) {
+        remotes[name] = {};
+      }
+      remotes[name][type.replace(/[()]/g, '')] = url;
+    });
+
+    return Object.entries(remotes).map(([name, urls]) => ({
+      name,
+      fetchUrl: urls.fetch,
+      pushUrl: urls.push
+    }));
+  }
+
+  /**
+   * Generate commit message for modifications
+   * @param {Object} modification - Modification details
+   * @returns {string} Generated commit message
+   */
+  generateCommitMessage(modification) {
+    const {
+      action,
+      componentType,
+      _componentName,
+      summary,
+      details = [],
+      breakingChanges = []
+    } = modification;
+
+    let message = `${action}(${componentType}): ${summary}`;
+    
+    if (details.length > 0) {
+      message += '\n\n' + details.map(d => `- ${d}`).join('\n');
+    }
+    
+    if (breakingChanges.length > 0) {
+      message += '\n\nBREAKING CHANGES:\n' + 
+        breakingChanges.map(bc => `- ${bc}`).join('\n');
+    }
+
+    return message;
+  }
+}
+
+module.exports = GitWrapper;