aios-core 2.1.0

package/.aios-core/infrastructure/scripts/git-config-detector.js

@@ -0,0 +1,293 @@
+/**
+ * Git Config Detector - Cached Git Configuration Detection
+ *
+ * Detects git configuration status with caching to avoid
+ * repeated git command execution overhead.
+ *
+ * Features:
+ * - 5-minute cache TTL (configurable)
+ * - Timeout protection (1000ms)
+ * - Smart cache invalidation
+ * - Graceful error handling
+ */
+
+const { execSync } = require('child_process');
+
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+const GIT_TIMEOUT = 1000; // 1 second
+
+class GitConfigDetector {
+  constructor(cacheTTL = DEFAULT_CACHE_TTL) {
+    this.cacheTTL = cacheTTL;
+    this.cache = null;
+    this.cacheTimestamp = null;
+  }
+
+  /**
+   * Get git configuration (cached)
+   * @returns {Object} { configured: boolean, type: string|null, branch: string|null }
+   */
+  get() {
+    // Check cache validity
+    if (this._isCacheValid()) {
+      return this.cache;
+    }
+
+    // Cache miss - detect configuration
+    return this.detect();
+  }
+
+  /**
+   * Detect git configuration (bypass cache)
+   * @returns {Object} { configured: boolean, type: string|null, branch: string|null }
+   */
+  detect() {
+    try {
+      const result = {
+        configured: false,
+        type: null,
+        branch: null,
+      };
+
+      // Check if git repository exists
+      if (!this._isGitRepository()) {
+        this._updateCache(result);
+        return result;
+      }
+
+      // Repository exists, get configuration details
+      result.configured = true;
+      result.branch = this._getCurrentBranch();
+
+      // Detect repository type (GitHub, GitLab, etc.)
+      const remoteUrl = this._getRemoteUrl();
+      result.type = this._detectRepositoryType(remoteUrl);
+
+      this._updateCache(result);
+      return result;
+    } catch (error) {
+      // Graceful fallback on any error
+      const fallbackResult = { configured: false, type: null, branch: null };
+      this._updateCache(fallbackResult);
+      return fallbackResult;
+    }
+  }
+
+  /**
+   * Invalidate cache (force fresh detection on next get())
+   */
+  invalidate() {
+    this.cache = null;
+    this.cacheTimestamp = null;
+  }
+
+  /**
+   * Check if cache is still valid
+   * @private
+   * @returns {boolean} True if cache is valid
+   */
+  _isCacheValid() {
+    if (!this.cache || !this.cacheTimestamp) {
+      return false;
+    }
+
+    const now = Date.now();
+    const age = now - this.cacheTimestamp;
+
+    return age < this.cacheTTL;
+  }
+
+  /**
+   * Update cache with new data
+   * @private
+   * @param {Object} data - Configuration data to cache
+   */
+  _updateCache(data) {
+    this.cache = data;
+    this.cacheTimestamp = Date.now();
+  }
+
+  /**
+   * Check if current directory is a git repository
+   * @private
+   * @returns {boolean} True if git repository
+   */
+  _isGitRepository() {
+    try {
+      const output = execSync('git rev-parse --is-inside-work-tree', {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT,
+        stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+      }).trim();
+
+      return output === 'true';
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get current git branch name
+   * @private
+   * @returns {string|null} Branch name or null
+   */
+  _getCurrentBranch() {
+    try {
+      const branch = execSync('git branch --show-current', {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT,
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim();
+
+      return branch || null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get remote repository URL
+   * @private
+   * @returns {string|null} Remote URL or null
+   */
+  _getRemoteUrl() {
+    try {
+      const url = execSync('git config --get remote.origin.url', {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT,
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim();
+
+      return url || null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Detect repository hosting type from URL
+   * @private
+   * @param {string|null} remoteUrl - Remote repository URL
+   * @returns {string|null} 'github' | 'gitlab' | 'bitbucket' | 'other' | null
+   */
+  _detectRepositoryType(remoteUrl) {
+    if (!remoteUrl) {
+      return null;
+    }
+
+    const url = remoteUrl.toLowerCase();
+
+    if (url.includes('github.com')) {
+      return 'github';
+    }
+
+    if (url.includes('gitlab.com') || url.includes('gitlab')) {
+      return 'gitlab';
+    }
+
+    if (url.includes('bitbucket.org') || url.includes('bitbucket')) {
+      return 'bitbucket';
+    }
+
+    // Has remote but unknown type
+    return 'other';
+  }
+
+  /**
+   * Get cache age in milliseconds
+   * @returns {number|null} Cache age or null if no cache
+   */
+  getCacheAge() {
+    if (!this.cacheTimestamp) {
+      return null;
+    }
+
+    return Date.now() - this.cacheTimestamp;
+  }
+
+  /**
+   * Check if cache will expire soon (within 1 minute)
+   * @returns {boolean} True if cache expires soon
+   */
+  isCacheExpiringSoon() {
+    const age = this.getCacheAge();
+    if (age === null) {
+      return true;
+    }
+
+    const remaining = this.cacheTTL - age;
+    return remaining < 60 * 1000; // Less than 1 minute remaining
+  }
+
+  /**
+   * Get detailed git information (bypass cache)
+   * Useful for debugging or detailed reports
+   * @returns {Object} Detailed git configuration
+   */
+  getDetailed() {
+    try {
+      const basic = this.detect();
+
+      if (!basic.configured) {
+        return basic;
+      }
+
+      // Get additional details
+      const userName = this._execGitCommand('git config user.name');
+      const userEmail = this._execGitCommand('git config user.email');
+      const remoteUrl = this._getRemoteUrl();
+      const lastCommit = this._execGitCommand('git log -1 --format=%H');
+      const hasUncommittedChanges = this._hasUncommittedChanges();
+
+      return {
+        ...basic,
+        userName,
+        userEmail,
+        remoteUrl,
+        lastCommit,
+        hasUncommittedChanges,
+      };
+    } catch (error) {
+      return this.detect(); // Fallback to basic detection
+    }
+  }
+
+  /**
+   * Execute git command with error handling
+   * @private
+   * @param {string} command - Git command to execute
+   * @returns {string|null} Command output or null
+   */
+  _execGitCommand(command) {
+    try {
+      return execSync(command, {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT,
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if repository has uncommitted changes
+   * @private
+   * @returns {boolean} True if has uncommitted changes
+   */
+  _hasUncommittedChanges() {
+    try {
+      const status = execSync('git status --porcelain', {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT,
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim();
+
+      return status.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = GitConfigDetector;

package/.aios-core/infrastructure/scripts/git-wrapper.js

@@ -0,0 +1,443 @@
+const { execa } = require('execa');
+const path = require('path');
+const fs = require('fs').promises;
+const chalk = require('chalk');
+
+/**
+ * GitWrapper - Centralized git operations for AIOS
+ *
+ * Refactored to use execa for cross-platform compatibility
+ * All git operations route through execGit() method
+ */
+class GitWrapper {
+  constructor(rootPath) {
+    this.rootPath = rootPath || process.cwd();
+    this.gitPath = 'git';
+  }
+
+  /**
+   * Execute git command using execa
+   *
+   * @param {string} command - Git command with arguments as string
+   * @param {object} options - Execution options
+   * @returns {string} Command stdout output
+   */
+  async execGit(command, options = {}) {
+    try {
+      // Split command string into array for execa
+      const args = command.split(' ');
+      const { stdout, stderr } = await execa(this.gitPath, args, {
+        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 current directory is a git repository
+   */
+  async isGitInitialized() {
+    try {
+      await this.execGit('rev-parse --git-dir');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Initialize a new git repository
+   */
+  async initializeRepository() {
+    try {
+      await this.execGit('init');
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to initialize git repository: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get current branch name
+   */
+  async getCurrentBranch() {
+    try {
+      return await this.execGit('rev-parse --abbrev-ref HEAD');
+    } catch (error) {
+      throw new Error(`Failed to get current branch: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a new branch
+   */
+  async createBranch(branchName, baseBranch = null) {
+    try {
+      if (baseBranch) {
+        await this.execGit(`checkout -b ${branchName} ${baseBranch}`);
+      } else {
+        await this.execGit(`checkout -b ${branchName}`);
+      }
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to create branch ${branchName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Checkout existing branch
+   */
+  async checkoutBranch(branchName) {
+    try {
+      await this.execGit(`checkout ${branchName}`);
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to checkout branch ${branchName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a modification branch with timestamp
+   */
+  async createModificationBranch(modificationId) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const branchName = `modification/${modificationId}/${timestamp}`;
+    await this.createBranch(branchName);
+    return branchName;
+  }
+
+  /**
+   * Stage files for commit
+   */
+  async stageFiles(files) {
+    try {
+      if (Array.isArray(files)) {
+        for (const file of files) {
+          await this.execGit(`add ${file}`);
+        }
+      } else {
+        await this.execGit(`add ${files}`);
+      }
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to stage files: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a commit
+   */
+  async commit(message, options = {}) {
+    try {
+      const commitArgs = ['commit', '-m', message];
+
+      if (options.allowEmpty) {
+        commitArgs.push('--allow-empty');
+      }
+
+      // Note: execa handles arguments array directly
+      const { stdout } = await execa(this.gitPath, commitArgs, {
+        cwd: this.rootPath,
+      });
+
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Failed to create commit: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a modification commit with metadata
+   */
+  async commitModification(modificationId, description, metadata = {}) {
+    const message = `[Modification ${modificationId}] ${description}
+
+Metadata:
+${JSON.stringify(metadata, null, 2)}`;
+
+    return await this.commit(message);
+  }
+
+  /**
+   * Get repository status
+   */
+  async getStatus() {
+    try {
+      const output = await this.execGit('status --porcelain');
+
+      const status = {
+        clean: !output,
+        modified: [],
+        staged: [],
+        untracked: [],
+      };
+
+      if (!output) return status;
+
+      const lines = output.split('\n').filter(line => line.trim());
+
+      for (const line of lines) {
+        const statusCode = line.substring(0, 2);
+        const file = line.substring(3);
+
+        if (statusCode[0] === 'M') {
+          status.staged.push(file);
+        } else if (statusCode[1] === 'M') {
+          status.modified.push(file);
+        } else if (statusCode === '??') {
+          status.untracked.push(file);
+        }
+      }
+
+      return status;
+    } catch (error) {
+      throw new Error(`Failed to get status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get commit history
+   */
+  async getHistory(limit = 10) {
+    try {
+      const output = await this.execGit(`log --oneline -n ${limit}`);
+      return output.split('\n').map(line => {
+        const [hash, ...messageParts] = line.split(' ');
+        return {
+          hash,
+          message: messageParts.join(' '),
+        };
+      });
+    } catch (error) {
+      throw new Error(`Failed to get history: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check for merge conflicts
+   */
+  async getConflicts() {
+    try {
+      const output = await this.execGit('diff --name-only --diff-filter=U');
+      return output ? output.split('\n').filter(f => f.trim()) : [];
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Merge a branch
+   */
+  async mergeBranch(branchName, options = {}) {
+    try {
+      const mergeArgs = ['merge', branchName];
+
+      if (options.noFf) {
+        mergeArgs.push('--no-ff');
+      }
+
+      if (options.message) {
+        mergeArgs.push('-m', options.message);
+      }
+
+      const { stdout } = await execa(this.gitPath, mergeArgs, {
+        cwd: this.rootPath,
+      });
+
+      return {
+        success: true,
+        output: stdout.trim(),
+      };
+    } catch (error) {
+      const conflicts = await this.getConflicts();
+      return {
+        success: false,
+        conflicts,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Create a git tag
+   */
+  async createTag(tagName, message = null) {
+    const tagArgs = message
+      ? `tag -a ${tagName} -m "${message}"`
+      : `tag ${tagName}`;
+
+    return await this.execGit(tagArgs);
+  }
+
+  /**
+   * Push to remote
+   */
+  async push(remote = 'origin', branch = null, options = {}) {
+    try {
+      const pushArgs = ['push', remote];
+
+      if (branch) {
+        pushArgs.push(branch);
+      }
+
+      if (options.setUpstream) {
+        pushArgs.push('--set-upstream');
+      }
+
+      if (options.force) {
+        pushArgs.push('--force');
+      }
+
+      const { stdout } = await execa(this.gitPath, pushArgs, {
+        cwd: this.rootPath,
+      });
+
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Failed to push: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get diff for files
+   */
+  async getDiff(files = null, options = {}) {
+    try {
+      let diffCommand = 'diff';
+
+      if (options.staged) {
+        diffCommand += ' --staged';
+      }
+
+      if (options.nameOnly) {
+        diffCommand += ' --name-only';
+      }
+
+      if (files) {
+        if (Array.isArray(files)) {
+          diffCommand += ' ' + files.join(' ');
+        } else {
+          diffCommand += ' ' + files;
+        }
+      }
+
+      return await this.execGit(diffCommand);
+    } catch (error) {
+      return '';
+    }
+  }
+
+  /**
+   * Stash changes
+   */
+  async stash(message = null) {
+    const stashCommand = message
+      ? `stash save "${message}"`
+      : 'stash';
+
+    return await this.execGit(stashCommand);
+  }
+
+  /**
+   * Apply stashed changes
+   */
+  async stashApply(stashRef = null) {
+    const applyCommand = stashRef
+      ? `stash apply ${stashRef}`
+      : 'stash apply';
+
+    return await this.execGit(applyCommand);
+  }
+
+  /**
+   * Get remote repositories
+   */
+  async getRemotes() {
+    try {
+      const output = await this.execGit('remote -v');
+      const remotes = {};
+
+      if (!output) return remotes;
+
+      const lines = output.split('\n').filter(line => line.trim());
+
+      for (const line of lines) {
+        const [name, url, type] = line.split(/\s+/);
+        if (!remotes[name]) {
+          remotes[name] = { fetch: null, push: null };
+        }
+        remotes[name][type.replace(/[()]/g, '')] = url;
+      }
+
+      return remotes;
+    } catch (error) {
+      return {};
+    }
+  }
+
+  /**
+   * Add remote repository
+   */
+  async addRemote(name, url) {
+    return await this.execGit(`remote add ${name} ${url}`);
+  }
+
+  /**
+   * Remove remote repository
+   */
+  async removeRemote(name) {
+    return await this.execGit(`remote remove ${name}`);
+  }
+
+  /**
+   * Fetch from remote
+   */
+  async fetch(remote = 'origin', options = {}) {
+    const fetchArgs = ['fetch', remote];
+
+    if (options.prune) {
+      fetchArgs.push('--prune');
+    }
+
+    if (options.all) {
+      fetchArgs.push('--all');
+    }
+
+    const { stdout } = await execa(this.gitPath, fetchArgs, {
+      cwd: this.rootPath,
+    });
+
+    return stdout.trim();
+  }
+
+  /**
+   * Pull from remote
+   */
+  async pull(remote = 'origin', branch = null, options = {}) {
+    const pullArgs = ['pull', remote];
+
+    if (branch) {
+      pullArgs.push(branch);
+    }
+
+    if (options.rebase) {
+      pullArgs.push('--rebase');
+    }
+
+    const { stdout } = await execa(this.gitPath, pullArgs, {
+      cwd: this.rootPath,
+    });
+
+    return stdout.trim();
+  }
+}
+
+module.exports = GitWrapper;