aios-core 2.1.0

package/.aios-core/development/scripts/dev-context-loader.js

@@ -0,0 +1,297 @@
+/**
+ * Dev Context Loader - Optimized File Loading for @dev Agent
+ *
+ * Loads devLoadAlwaysFiles with smart caching and summarization.
+ * Reduces ~2,300 lines to ~500 lines summary on initial load.
+ * Full files loaded only when needed for specific tasks.
+ *
+ * Part of Story 6.1.2.6 Performance Optimization
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+const CACHE_DIR = path.join(process.cwd(), '.aios', 'cache');
+const CACHE_TTL = 3600 * 1000; // 1 hour
+
+class DevContextLoader {
+  constructor() {
+    this.coreConfigPath = path.join(process.cwd(), '.aios-core', 'core-config.yaml');
+    this.summaryCache = new Map();
+    this.cacheDir = CACHE_DIR; // Make configurable for testing
+  }
+
+  /**
+   * Load dev context files with smart caching
+   *
+   * @param {Object} options - Load options
+   * @param {boolean} options.fullLoad - Load full files instead of summaries
+   * @param {boolean} options.skipCache - Skip cache and force reload
+   * @returns {Promise<Object>} Context data
+   */
+  async load(options = {}) {
+    const fullLoad = options.fullLoad || false;
+    const skipCache = options.skipCache || false;
+
+    const startTime = Date.now();
+
+    // Load core config to get devLoadAlwaysFiles list
+    const coreConfig = await this.loadCoreConfig();
+    const fileList = coreConfig.devLoadAlwaysFiles || [];
+
+    if (fileList.length === 0) {
+      return {
+        status: 'no_files',
+        loadTime: Date.now() - startTime,
+        files: [],
+      };
+    }
+
+    // Load files (with cache)
+    const files = await this.loadFiles(fileList, { fullLoad, skipCache });
+
+    const loadTime = Date.now() - startTime;
+
+    return {
+      status: 'loaded',
+      loadTime,
+      loadStrategy: fullLoad ? 'full' : 'summary',
+      files,
+      filesCount: files.length,
+      totalLines: files.reduce((sum, f) => sum + (f.linesCount || 0), 0),
+      cacheHits: files.filter(f => f.cached).length,
+    };
+  }
+
+  /**
+   * Load core config
+   *
+   * @returns {Promise<Object>} Core configuration
+   */
+  async loadCoreConfig() {
+    try {
+      const content = await fs.readFile(this.coreConfigPath, 'utf8');
+      return yaml.load(content);
+    } catch (error) {
+      console.warn('⚠️ Could not load core-config.yaml:', error.message);
+      return {};
+    }
+  }
+
+  /**
+   * Load files with caching
+   *
+   * @param {Array<string>} fileList - List of file paths
+   * @param {Object} options - Load options
+   * @returns {Promise<Array>} Loaded files
+   */
+  async loadFiles(fileList, options = {}) {
+    const { fullLoad, skipCache } = options;
+    const results = [];
+
+    for (const filePath of fileList) {
+      const absolutePath = path.join(process.cwd(), filePath);
+
+      try {
+        // Check if file exists
+        await fs.access(absolutePath);
+
+        // Try to load from cache
+        if (!skipCache) {
+          const cached = await this.loadFromCache(filePath, fullLoad);
+          if (cached) {
+            results.push({ ...cached, cached: true });
+            continue;
+          }
+        }
+
+        // Load from disk
+        const content = await fs.readFile(absolutePath, 'utf8');
+        const lines = content.split('\n');
+        const linesCount = lines.length;
+
+        let fileData;
+        if (fullLoad) {
+          // Full load
+          fileData = {
+            path: filePath,
+            content,
+            linesCount,
+            cached: false,
+          };
+        } else {
+          // Summary load
+          const summary = this.generateSummary(filePath, content, lines);
+          fileData = {
+            path: filePath,
+            summary,
+            linesCount,
+            summaryLines: summary.split('\n').length,
+            cached: false,
+            note: 'Use *load-full to load complete file',
+          };
+        }
+
+        // Save to cache
+        await this.saveToCache(filePath, fileData, fullLoad);
+
+        results.push(fileData);
+      } catch (error) {
+        // File not found or read error - continue
+        console.warn(`⚠️ Could not load ${filePath}:`, error.message);
+        results.push({
+          path: filePath,
+          error: error.message,
+          cached: false,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Generate file summary (first 100 lines + key sections)
+   *
+   * @param {string} filePath - File path
+   * @param {string} content - Full content
+   * @param {Array<string>} lines - Content lines
+   * @returns {string} Summary
+   */
+  generateSummary(filePath, content, lines) {
+    const fileName = path.basename(filePath);
+
+    // Extract key sections (h1, h2 headers)
+    const headers = lines
+      .filter(line => line.match(/^#{1,2}\s+/))
+      .slice(0, 20); // First 20 headers
+
+    // First 100 lines
+    const preview = lines.slice(0, 100);
+
+    const summary = [
+      `📄 ${fileName} (${lines.length} lines)`,
+      '',
+      '## Key Sections:',
+      ...headers.map(h => `- ${h.replace(/^#+\s*/, '')}`),
+      '',
+      '## Preview (first 100 lines):',
+      '```',
+      ...preview,
+      '```',
+      '',
+      `...and ${Math.max(0, lines.length - 100)} more lines`,
+    ];
+
+    return summary.join('\n');
+  }
+
+  /**
+   * Load from cache
+   *
+   * @param {string} filePath - File path
+   * @param {boolean} fullLoad - Full load flag
+   * @returns {Promise<Object|null>} Cached data or null
+   */
+  async loadFromCache(filePath, fullLoad) {
+    const cacheKey = this.getCacheKey(filePath, fullLoad);
+    const cachePath = path.join(this.cacheDir, `${cacheKey}.json`);
+
+    try {
+      const stat = await fs.stat(cachePath);
+      const age = Date.now() - stat.mtimeMs;
+
+      if (age > CACHE_TTL) {
+        // Cache expired
+        return null;
+      }
+
+      const cached = JSON.parse(await fs.readFile(cachePath, 'utf8'));
+      return cached;
+    } catch (error) {
+      // Cache miss
+      return null;
+    }
+  }
+
+  /**
+   * Save to cache
+   *
+   * @param {string} filePath - File path
+   * @param {Object} data - Data to cache
+   * @param {boolean} fullLoad - Full load flag
+   * @returns {Promise<void>}
+   */
+  async saveToCache(filePath, data, fullLoad) {
+    const cacheKey = this.getCacheKey(filePath, fullLoad);
+    const cachePath = path.join(this.cacheDir, `${cacheKey}.json`);
+
+    try {
+      // Ensure cache directory exists
+      await fs.mkdir(this.cacheDir, { recursive: true });
+
+      await fs.writeFile(cachePath, JSON.stringify(data, null, 2), 'utf8');
+    } catch (error) {
+      // Cache write error - not critical
+      console.warn('⚠️ Could not save cache:', error.message);
+    }
+  }
+
+  /**
+   * Get cache key for file
+   *
+   * @param {string} filePath - File path
+   * @param {boolean} fullLoad - Full load flag
+   * @returns {string} Cache key
+   */
+  getCacheKey(filePath, fullLoad) {
+    const normalized = filePath.replace(/[^a-zA-Z0-9]/g, '_');
+    const type = fullLoad ? 'full' : 'summary';
+    return `devcontext_${normalized}_${type}`;
+  }
+
+  /**
+   * Clear cache
+   *
+   * @returns {Promise<void>}
+   */
+  async clearCache() {
+    try {
+      const files = await fs.readdir(this.cacheDir);
+      const devContextFiles = files.filter(f => f.startsWith('devcontext_'));
+
+      for (const file of devContextFiles) {
+        await fs.unlink(path.join(this.cacheDir, file));
+      }
+
+      console.log(`✅ Cleared ${devContextFiles.length} cache files`);
+    } catch (error) {
+      console.warn('⚠️ Could not clear cache:', error.message);
+    }
+  }
+}
+
+// CLI Interface
+if (require.main === module) {
+  const loader = new DevContextLoader();
+  const command = process.argv[2];
+
+  (async () => {
+    if (command === 'clear-cache') {
+      await loader.clearCache();
+    } else if (command === 'load-full') {
+      const result = await loader.load({ fullLoad: true });
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Default: summary load
+      const result = await loader.load({ fullLoad: false });
+      console.log(JSON.stringify(result, null, 2));
+    }
+  })().catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = DevContextLoader;

package/.aios-core/development/scripts/generate-greeting.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Unified Greeting Generator
+ * 
+ * Orchestrates all greeting components for optimal performance:
+ * - Agent definition (via expanded agent-config-loader.js)
+ * - Session context (session-context-loader.js)
+ * - Project status (project-status-loader.js)
+ * - User preferences (greeting-preference-manager.js)
+ * - Contextual adaptation (greeting-builder.js)
+ * 
+ * Performance Targets:
+ * - With cache: <50ms
+ * - Without cache: <150ms (timeout protection)
+ * - Fallback: <10ms
+ * 
+ * Usage: node generate-greeting.js <agent-id>
+ * 
+ * Part of Story 6.1.4: Unified Greeting System Integration
+ */
+
+const GreetingBuilder = require('./greeting-builder');
+const SessionContextLoader = require('../../scripts/session-context-loader');
+const { loadProjectStatus } = require('../../infrastructure/scripts/project-status-loader');
+const { AgentConfigLoader } = require('./agent-config-loader');
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('yaml');
+
+/**
+ * Generate unified greeting for agent activation
+ * 
+ * @param {string} agentId - Agent identifier (e.g., 'qa', 'dev')
+ * @returns {Promise<string>} Formatted greeting string
+ * @throws {Error} If agent file not found or invalid
+ * 
+ * @example
+ * const greeting = await generateGreeting('qa');
+ * console.log(greeting);
+ */
+async function generateGreeting(agentId) {
+  const startTime = Date.now();
+  
+  try {
+    // Load core config
+    const coreConfigPath = path.join(process.cwd(), '.aios-core', 'core-config.yaml');
+    const coreConfigContent = await fs.readFile(coreConfigPath, 'utf8');
+    const coreConfig = yaml.parse(coreConfigContent);
+    
+    // Load everything in parallel using expanded AgentConfigLoader
+    const loader = new AgentConfigLoader(agentId);
+    
+    const [complete, sessionContext, projectStatus] = await Promise.all([
+      loader.loadComplete(coreConfig), // Loads config + definition
+      loadSessionContext(agentId),
+      loadProjectStatus(),
+    ]);
+    
+    // Build unified context
+    const context = {
+      conversationHistory: [], // Not available in Claude Code
+      sessionType: sessionContext.sessionType, // Pre-detected
+      projectStatus: projectStatus, // Pre-loaded
+      lastCommands: sessionContext.lastCommands || [],
+      previousAgent: sessionContext.previousAgent,
+      sessionMessage: sessionContext.message,
+      workflowActive: sessionContext.workflowActive,
+      sessionStory: sessionContext.currentStory || null, // Session's current story (more accurate than git)
+    };
+    
+    // Ensure agent has persona_profile and persona from definition
+    const agentWithPersona = {
+      ...complete.agent,
+      persona_profile: complete.persona_profile || complete.definition?.persona_profile,
+      persona: complete.definition?.persona || complete.persona,
+      commands: complete.commands || complete.definition?.commands || [],
+    };
+    
+    // Generate greeting using GreetingBuilder
+    const builder = new GreetingBuilder();
+    const greeting = await builder.buildGreeting(agentWithPersona, context);
+    
+    const duration = Date.now() - startTime;
+    if (duration > 100) {
+      console.warn(`[generate-greeting] Slow generation: ${duration}ms`);
+    }
+    
+    return 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);
+  }
+}
+
+/**
+ * Load session context for agent
+ * @private
+ * @param {string} agentId - Agent ID
+ * @returns {Promise<Object>} Session context
+ */
+async function loadSessionContext(agentId) {
+  try {
+    const loader = new SessionContextLoader();
+    return loader.loadContext(agentId);
+  } catch (error) {
+    console.warn('[generate-greeting] Session context failed:', error.message);
+    return {
+      sessionType: 'new',
+      message: null,
+      previousAgent: null,
+      lastCommands: [],
+      workflowActive: null,
+    };
+  }
+}
+
+/**
+ * Generate fallback greeting if everything fails
+ * @private
+ * @param {string} agentId - Agent ID
+ * @returns {string} Simple fallback greeting
+ */
+function generateFallbackGreeting(agentId) {
+  return `✅ ${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 };
+