aios-core 2.1.0

package/.aios-core/infrastructure/scripts/pm-adapter.js

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Base interface for Project Management tool adapters
+ *
+ * This file defines the PMAdapter base class that all PM tool adapters must extend.
+ * Supports ClickUp, GitHub Projects, Jira, and local-only modes.
+ *
+ * @see Story 3.20 - PM Tool-Agnostic Integration
+ */
+
+/**
+ * Base class for Project Management tool adapters
+ *
+ * All PM tool adapters (ClickUp, GitHub, Jira, Local) must extend this class
+ * and implement all abstract methods.
+ *
+ * @abstract
+ */
+class PMAdapter {
+  /**
+   * Create a PM adapter instance
+   * @param {object} config - Adapter-specific configuration
+   */
+  constructor(config = {}) {
+    this.config = config;
+  }
+
+  /**
+   * Sync local story to PM tool
+   *
+   * Pushes the current state of a story YAML file to the configured PM tool.
+   * Creates or updates the corresponding item in the PM tool.
+   *
+   * @param {string} storyPath - Absolute path to story YAML file
+   * @returns {Promise<{success: boolean, url?: string, error?: string}>}
+   * @throws {Error} If not implemented by subclass
+   *
+   * @example
+   * const result = await adapter.syncStory('/path/to/story/3.20.yaml');
+   * if (result.success) {
+   *   console.log('Story synced:', result.url);
+   * }
+   */
+  async syncStory(_storyPath) {
+    throw new Error('syncStory must be implemented by adapter');
+  }
+
+  /**
+   * Pull story updates from PM tool
+   *
+   * Retrieves the current state of a story from the PM tool and returns
+   * any updates that differ from the local YAML file.
+   *
+   * @param {string} storyId - Story ID (e.g., "3.14")
+   * @returns {Promise<{success: boolean, updates?: object, error?: string}>}
+   * @throws {Error} If not implemented by subclass
+   *
+   * @example
+   * const result = await adapter.pullStory('3.20');
+   * if (result.success && result.updates) {
+   *   console.log('Story has updates:', result.updates);
+   * }
+   */
+  async pullStory(_storyId) {
+    throw new Error('pullStory must be implemented by adapter');
+  }
+
+  /**
+   * Create new story in PM tool
+   *
+   * Creates a new item in the PM tool based on story metadata.
+   * Does not modify the local YAML file.
+   *
+   * @param {object} storyData - Story metadata (id, title, description, etc.)
+   * @returns {Promise<{success: boolean, url?: string, error?: string}>}
+   * @throws {Error} If not implemented by subclass
+   *
+   * @example
+   * const result = await adapter.createStory({
+   *   id: '3.20',
+   *   title: 'PM Tool-Agnostic Integration',
+   *   description: 'Remove hard-coded ClickUp dependency'
+   * });
+   */
+  async createStory(_storyData) {
+    throw new Error('createStory must be implemented by adapter');
+  }
+
+  /**
+   * Update story status in PM tool
+   *
+   * Updates only the status field of a story in the PM tool.
+   * Useful for workflow state transitions (Draft → InProgress → Done).
+   *
+   * @param {string} storyId - Story ID (e.g., "3.14")
+   * @param {string} status - New status (Draft, InProgress, Review, Done)
+   * @returns {Promise<{success: boolean, error?: string}>}
+   * @throws {Error} If not implemented by subclass
+   *
+   * @example
+   * await adapter.updateStatus('3.20', 'InProgress');
+   */
+  async updateStatus(_storyId, _status) {
+    throw new Error('updateStatus must be implemented by adapter');
+  }
+
+  /**
+   * Test connection to PM tool
+   *
+   * Validates that the adapter can connect to the PM tool with the
+   * provided configuration. Used during initial setup.
+   *
+   * @returns {Promise<{success: boolean, error?: string}>}
+   * @throws {Error} If not implemented by subclass
+   *
+   * @example
+   * const result = await adapter.testConnection();
+   * if (!result.success) {
+   *   console.error('Connection failed:', result.error);
+   * }
+   */
+  async testConnection() {
+    throw new Error('testConnection must be implemented by adapter');
+  }
+
+  /**
+   * Get adapter name
+   * @returns {string} Adapter name (e.g., 'ClickUp', 'GitHub Projects')
+   */
+  getName() {
+    return this.constructor.name.replace('Adapter', '');
+  }
+}
+
+module.exports = { PMAdapter };

package/.aios-core/infrastructure/scripts/project-status-loader.js

@@ -0,0 +1,445 @@
+const { execa } = require('execa');
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * ProjectStatusLoader - Dynamic project status for agent activation context
+ *
+ * Story 6.1.2.4: Captures git state, recent work, and current story/epic
+ * for display in agent greetings across all 11 AIOS agents.
+ *
+ * Features:
+ * - Git integration (branch, status, recent commits)
+ * - Current story/epic detection from docs/stories/
+ * - 60-second cache mechanism for performance
+ * - Cross-platform support (Windows/Linux/macOS)
+ * - Graceful fallback for non-git projects
+ */
+class ProjectStatusLoader {
+  constructor(rootPath = null) {
+    this.rootPath = rootPath || process.cwd();
+    this.cacheFile = path.join(this.rootPath, '.aios', 'project-status.yaml');
+    this.cacheTTL = 60; // seconds
+
+    // Load config values (QA Fix: Issue 6.1.2.4-I1)
+    this.config = this.loadConfig();
+    this.maxModifiedFiles = this.config?.projectStatus?.maxModifiedFiles || 5;
+    this.maxRecentCommits = this.config?.projectStatus?.maxRecentCommits || 2;
+  }
+
+  /**
+   * Load configuration from core-config.yaml
+   *
+   * @returns {Object|null} Config object or null if not found
+   */
+  loadConfig() {
+    try {
+      const configPath = path.join(this.rootPath, '.aios-core', 'core-config.yaml');
+      const configContent = require('fs').readFileSync(configPath, 'utf8');
+      return yaml.load(configContent);
+    } catch (error) {
+      // Config not found - use defaults
+      return null;
+    }
+  }
+
+  /**
+   * Load project status with caching
+   *
+   * @returns {Promise<ProjectStatus>} Current project status
+   */
+  async loadProjectStatus() {
+    try {
+      // Try to load from cache first
+      const cached = await this.loadCache();
+      if (cached && this.isCacheValid(cached)) {
+        return cached.status;
+      }
+
+      // Cache miss or expired - generate fresh status
+      const status = await this.generateStatus();
+
+      // Save to cache
+      await this.saveCache(status);
+
+      return status;
+    } catch (error) {
+      console.warn('Project status loading failed, using defaults:', error.message);
+      return this.getDefaultStatus();
+    }
+  }
+
+  /**
+   * Generate fresh project status
+   *
+   * @returns {Promise<ProjectStatus>}
+   */
+  async generateStatus() {
+    const isGit = await this.isGitRepository();
+
+    if (!isGit) {
+      return this.getNonGitStatus();
+    }
+
+    const [branch, modifiedFilesResult, recentCommits, storyInfo] = await Promise.all([
+      this.getGitBranch(),
+      this.getModifiedFiles(),
+      this.getRecentCommits(),
+      this.getCurrentStoryInfo(),
+    ]);
+
+    return {
+      branch,
+      modifiedFiles: modifiedFilesResult.files,
+      modifiedFilesTotalCount: modifiedFilesResult.totalCount,
+      recentCommits,
+      currentEpic: storyInfo.epic || null,
+      currentStory: storyInfo.story || null,
+      lastUpdate: new Date().toISOString(),
+      isGitRepo: true,
+    };
+  }
+
+  /**
+   * Check if current directory is a git repository
+   *
+   * @returns {Promise<boolean>}
+   */
+  async isGitRepository() {
+    try {
+      await execa('git', ['rev-parse', '--is-inside-work-tree'], {
+        cwd: this.rootPath,
+        stderr: 'ignore',
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get current git branch name
+   *
+   * @returns {Promise<string>}
+   */
+  async getGitBranch() {
+    try {
+      // Try modern git command first (git >= 2.22)
+      const { stdout } = await execa('git', ['branch', '--show-current'], {
+        cwd: this.rootPath,
+      });
+      return stdout.trim();
+    } catch (error) {
+      // Fallback for older git versions
+      try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+          cwd: this.rootPath,
+        });
+        return stdout.trim();
+      } catch (fallbackError) {
+        return 'unknown';
+      }
+    }
+  }
+
+  /**
+   * Get modified files from git status
+   *
+   * @returns {Promise<string[]>}
+   */
+  async getModifiedFiles() {
+    try {
+      const { stdout } = await execa('git', ['status', '--porcelain'], {
+        cwd: this.rootPath,
+      });
+
+      if (!stdout) return { files: [], totalCount: 0 };
+
+      // Parse porcelain output
+      const allFiles = stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+          // Remove status prefix (e.g., " M ", "A  ", "?? ")
+          return line.substring(3).trim();
+        });
+
+      const totalCount = allFiles.length;
+      const files = allFiles.slice(0, this.maxModifiedFiles); // Use config value
+
+      return { files, totalCount };
+    } catch (error) {
+      return { files: [], totalCount: 0 };
+    }
+  }
+
+  /**
+   * Get recent commits
+   *
+   * @returns {Promise<string[]>}
+   */
+  async getRecentCommits() {
+    try {
+      const { stdout } = await execa('git', ['log', `-${this.maxRecentCommits}`, '--oneline', '--no-decorate'], {
+        cwd: this.rootPath,
+      });
+
+      if (!stdout) return [];
+
+      // Parse commit lines (remove hash, keep message)
+      const commits = stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+          // Remove commit hash (first 7-8 characters)
+          return line.substring(8).trim();
+        });
+
+      return commits;
+    } catch (error) {
+      // No commits yet or error
+      return [];
+    }
+  }
+
+  /**
+   * Detect current story and epic from docs/stories/
+   *
+   * Scans for Status: InProgress or Status: In Progress
+   *
+   * @returns {Promise<{story: string|null, epic: string|null}>}
+   */
+  async getCurrentStoryInfo() {
+    try {
+      const storiesDir = path.join(this.rootPath, 'docs', 'stories');
+
+      // Check if stories directory exists
+      try {
+        await fs.access(storiesDir);
+      } catch {
+        return { story: null, epic: null };
+      }
+
+      // Read all markdown files recursively
+      const storyFiles = await this.findMarkdownFiles(storiesDir);
+
+      for (const file of storyFiles) {
+        const content = await fs.readFile(file, 'utf8');
+
+        // Check for InProgress status
+        const statusMatch = content.match(/\*\*Status:\*\*\s*(InProgress|In Progress|🔄\s*InProgress|🔄\s*In Progress)/i);
+
+        if (statusMatch) {
+          // Extract story ID and epic
+          const storyIdMatch = content.match(/\*\*Story ID:\*\*\s*([A-Z]+-[\d.]+)/);
+          const epicMatch = content.match(/\*\*Epic:\*\*\s*([^\n]+)/);
+
+          return {
+            story: storyIdMatch ? storyIdMatch[1] : path.basename(file, '.md'),
+            epic: epicMatch ? epicMatch[1].trim() : null,
+          };
+        }
+      }
+
+      return { story: null, epic: null };
+    } catch (error) {
+      return { story: null, epic: null };
+    }
+  }
+
+  /**
+   * Find all markdown files in directory recursively
+   *
+   * @param {string} dir - Directory to search
+   * @returns {Promise<string[]>}
+   */
+  async findMarkdownFiles(dir) {
+    const files = [];
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          const subFiles = await this.findMarkdownFiles(fullPath);
+          files.push(...subFiles);
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Ignore errors (permission denied, etc.)
+    }
+
+    return files;
+  }
+
+  /**
+   * Load status from cache file
+   *
+   * @returns {Promise<{status: ProjectStatus, timestamp: number, ttl: number}|null>}
+   */
+  async loadCache() {
+    try {
+      const content = await fs.readFile(this.cacheFile, 'utf8');
+      return yaml.load(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if cache is still valid
+   *
+   * @param {{timestamp: number, ttl: number}} cache
+   * @returns {boolean}
+   */
+  isCacheValid(cache) {
+    if (!cache || !cache.timestamp) return false;
+
+    const age = Date.now() - cache.timestamp;
+    const ttl = cache.ttl || this.cacheTTL;
+
+    return age < (ttl * 1000);
+  }
+
+  /**
+   * Save status to cache file
+   *
+   * @param {ProjectStatus} status
+   */
+  async saveCache(status) {
+    try {
+      // Ensure .aios directory exists
+      const cacheDir = path.dirname(this.cacheFile);
+      await fs.mkdir(cacheDir, { recursive: true });
+
+      const cache = {
+        status,
+        timestamp: Date.now(),
+        ttl: this.cacheTTL,
+      };
+
+      const content = yaml.dump(cache);
+      await fs.writeFile(this.cacheFile, content, 'utf8');
+    } catch (error) {
+      // Cache write failure is non-critical, just log
+      console.warn('Failed to write status cache:', error.message);
+    }
+  }
+
+  /**
+   * Clear cache file
+   */
+  async clearCache() {
+    try {
+      await fs.unlink(this.cacheFile);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get default status for non-git projects
+   *
+   * @returns {ProjectStatus}
+   */
+  getNonGitStatus() {
+    return {
+      branch: null,
+      modifiedFiles: [],
+      recentCommits: [],
+      currentEpic: null,
+      currentStory: null,
+      lastUpdate: new Date().toISOString(),
+      isGitRepo: false,
+    };
+  }
+
+  /**
+   * Get default status on error
+   *
+   * @returns {ProjectStatus}
+   */
+  getDefaultStatus() {
+    return {
+      branch: 'unknown',
+      modifiedFiles: [],
+      recentCommits: [],
+      currentEpic: null,
+      currentStory: null,
+      lastUpdate: new Date().toISOString(),
+      isGitRepo: false,
+    };
+  }
+
+  /**
+   * Format status for display in agent greeting
+   *
+   * @param {ProjectStatus} status
+   * @returns {string}
+   */
+  formatStatusDisplay(status) {
+    if (!status.isGitRepo) {
+      return '  (Not a git repository)';
+    }
+
+    const lines = [];
+
+    if (status.branch) {
+      lines.push(`  - Branch: ${status.branch}`);
+    }
+
+    if (status.modifiedFiles && status.modifiedFiles.length > 0) {
+      let filesDisplay = status.modifiedFiles.join(', ');
+
+      // QA Fix: Issue 6.1.2.4-I3 - Add truncation message
+      const totalCount = status.modifiedFilesTotalCount || status.modifiedFiles.length;
+      if (totalCount > status.modifiedFiles.length) {
+        const remaining = totalCount - status.modifiedFiles.length;
+        filesDisplay += ` ...and ${remaining} more`;
+      }
+
+      lines.push(`  - Modified: ${filesDisplay}`);
+    }
+
+    if (status.recentCommits && status.recentCommits.length > 0) {
+      lines.push(`  - Recent: ${status.recentCommits.join(', ')}`);
+    }
+
+    if (status.currentStory) {
+      lines.push(`  - Story: ${status.currentStory}`);
+    }
+
+    if (lines.length === 0) {
+      return '  (No recent activity)';
+    }
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * @typedef {Object} ProjectStatus
+ * @property {string|null} branch - Current git branch
+ * @property {string[]} modifiedFiles - List of modified files (max 5)
+ * @property {string[]} recentCommits - Recent commit messages (max 2)
+ * @property {string|null} currentEpic - Current epic name
+ * @property {string|null} currentStory - Current story ID
+ * @property {string} lastUpdate - ISO timestamp of last update
+ * @property {boolean} isGitRepo - Whether this is a git repository
+ */
+
+// Export singleton instance
+const loader = new ProjectStatusLoader();
+
+module.exports = {
+  loadProjectStatus: () => loader.loadProjectStatus(),
+  clearCache: () => loader.clearCache(),
+  formatStatusDisplay: (status) => loader.formatStatusDisplay(status),
+  ProjectStatusLoader,
+};