create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/dev-context-loader.js

@@ -0,0 +1,296 @@
+/**
+ * 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(), '.aiox', 'cache');
+const CACHE_TTL = 3600 * 1000; // 1 hour
+
+class DevContextLoader {
+  constructor() {
+    this.coreConfigPath = path.join(process.cwd(), '.aiox-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
+    // TD-6: Handle null/undefined coreConfig gracefully
+    const coreConfig = await this.loadCoreConfig();
+    const fileList = (coreConfig && 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/template/.aiox-core/development/scripts/diff-generator.js

@@ -0,0 +1,352 @@
+const diffLib = require('diff');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+
+/**
+ * Generates visual diffs for component modifications
+ */
+class DiffGenerator {
+  constructor() {
+    this.colors = {
+      added: chalk.green,
+      removed: chalk.red,
+      unchanged: chalk.gray,
+      header: chalk.cyan,
+      lineNumber: chalk.yellow
+    };
+  }
+
+  /**
+   * Generate a unified diff between two text contents
+   * @param {string} originalContent - Original file content
+   * @param {string} modifiedContent - Modified file content
+   * @param {string} fileName - Name of the file being diffed
+   * @param {Object} options - Diff options
+   * @returns {string} Formatted diff output
+   */
+  generateUnifiedDiff(originalContent, modifiedContent, fileName, options = {}) {
+    const {
+      contextLines = 3,
+      showLineNumbers = true,
+      colorize = true
+    } = options;
+
+    const patch = diffLib.createPatch(
+      fileName,
+      originalContent,
+      modifiedContent,
+      'Current Version',
+      'Modified Version',
+      { context: contextLines }
+    );
+
+    if (!colorize) {
+      return patch;
+    }
+
+    return this.colorizeDiff(patch, showLineNumbers);
+  }
+
+  /**
+   * Generate a diff specifically for YAML content
+   * @param {string} originalYaml - Original YAML content
+   * @param {string} modifiedYaml - Modified YAML content
+   * @param {string} componentName - Name of the component
+   * @returns {Object} Structured diff with sections
+   */
+  generateYamlDiff(originalYaml, modifiedYaml, componentName) {
+    const original = yaml.load(originalYaml);
+    const modified = yaml.load(modifiedYaml);
+
+    const diff = {
+      component: componentName,
+      sections: {},
+      summary: {
+        added: [],
+        removed: [],
+        modified: []
+      }
+    };
+
+    // Compare top-level keys
+    const allKeys = new Set([...Object.keys(original), ...Object.keys(modified)]);
+
+    for (const key of allKeys) {
+      if (!original.hasOwnProperty(key)) {
+        diff.sections[key] = { status: 'added', value: modified[key] };
+        diff.summary.added.push(key);
+      } else if (!modified.hasOwnProperty(key)) {
+        diff.sections[key] = { status: 'removed', value: original[key] };
+        diff.summary.removed.push(key);
+      } else if (JSON.stringify(original[key]) !== JSON.stringify(modified[key])) {
+        diff.sections[key] = {
+          status: 'modified',
+          original: original[key],
+          modified: modified[key],
+          changes: this.compareValues(original[key], modified[key])
+        };
+        diff.summary.modified.push(key);
+      }
+    }
+
+    return diff;
+  }
+
+  /**
+   * Generate a structured diff for agents
+   * @param {string} originalContent - Original agent content
+   * @param {string} modifiedContent - Modified agent content
+   * @param {string} agentName - Name of the agent
+   * @returns {Object} Structured agent diff
+   */
+  generateAgentDiff(originalContent, modifiedContent, agentName) {
+    // Split content into YAML and markdown sections
+    const originalParts = this.splitAgentContent(originalContent);
+    const modifiedParts = this.splitAgentContent(modifiedContent);
+
+    const yamlDiff = this.generateYamlDiff(
+      originalParts.yaml,
+      modifiedParts.yaml,
+      agentName
+    );
+
+    const markdownDiff = this.generateUnifiedDiff(
+      originalParts.markdown,
+      modifiedParts.markdown,
+      `${agentName}.md`,
+      { contextLines: 5 }
+    );
+
+    return {
+      agent: agentName,
+      yamlChanges: yamlDiff,
+      markdownChanges: markdownDiff,
+      impactSummary: this.generateImpactSummary(yamlDiff)
+    };
+  }
+
+  /**
+   * Generate a visual diff summary
+   * @param {Object} diff - Structured diff object
+   * @returns {string} Formatted summary
+   */
+  generateDiffSummary(diff) {
+    const lines = [];
+    
+    lines.push(this.colors.header('=== Modification Summary ==='));
+    lines.push('');
+
+    if (diff.summary) {
+      if (diff.summary.added.length > 0) {
+        lines.push(this.colors.added(`+ Added (${diff.summary.added.length}):`));
+        diff.summary.added.forEach(item => {
+          lines.push(this.colors.added(`  + ${item}`));
+        });
+        lines.push('');
+      }
+
+      if (diff.summary.modified.length > 0) {
+        lines.push(this.colors.header(`~ Modified (${diff.summary.modified.length}):`));
+        diff.summary.modified.forEach(item => {
+          lines.push(this.colors.header(`  ~ ${item}`));
+        });
+        lines.push('');
+      }
+
+      if (diff.summary.removed.length > 0) {
+        lines.push(this.colors.removed(`- Removed (${diff.summary.removed.length}):`));
+        diff.summary.removed.forEach(item => {
+          lines.push(this.colors.removed(`  - ${item}`));
+        });
+        lines.push('');
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Split agent content into YAML and markdown sections
+   * @private
+   */
+  splitAgentContent(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match) {
+      throw new Error('Invalid agent content format');
+    }
+
+    return {
+      yaml: match[1],
+      markdown: match[2]
+    };
+  }
+
+  /**
+   * Compare two values and generate change details
+   * @private
+   */
+  compareValues(original, modified) {
+    const changes = [];
+
+    if (Array.isArray(original) && Array.isArray(modified)) {
+      const added = modified.filter(item => !original.includes(item));
+      const removed = original.filter(item => !modified.includes(item));
+
+      if (added.length > 0) {
+        changes.push({ type: 'added', items: added });
+      }
+      if (removed.length > 0) {
+        changes.push({ type: 'removed', items: removed });
+      }
+    } else if (typeof original === 'object' && typeof modified === 'object') {
+      const allKeys = new Set([...Object.keys(original), ...Object.keys(modified)]);
+      
+      for (const key of allKeys) {
+        if (!original.hasOwnProperty(key)) {
+          changes.push({ type: 'added', key, value: modified[key] });
+        } else if (!modified.hasOwnProperty(key)) {
+          changes.push({ type: 'removed', key, value: original[key] });
+        } else if (JSON.stringify(original[key]) !== JSON.stringify(modified[key])) {
+          changes.push({
+            type: 'modified',
+            key,
+            original: original[key],
+            modified: modified[key]
+          });
+        }
+      }
+    } else {
+      changes.push({
+        type: 'value_changed',
+        original,
+        modified
+      });
+    }
+
+    return changes;
+  }
+
+  /**
+   * Colorize a diff patch
+   * @private
+   */
+  colorizeDiff(patch, showLineNumbers) {
+    const lines = patch.split('\n');
+    const colorized = [];
+    let lineNumOriginal = 0;
+    let lineNumModified = 0;
+
+    for (const line of lines) {
+      if (line.startsWith('@@')) {
+        // Parse line numbers from hunk header
+        const match = line.match(/@@ -(\d+),\d+ \+(\d+),\d+ @@/);
+        if (match) {
+          lineNumOriginal = parseInt(match[1]);
+          lineNumModified = parseInt(match[2]);
+        }
+        colorized.push(this.colors.header(line));
+      } else if (line.startsWith('+')) {
+        const lineNum = showLineNumbers ? `${lineNumModified.toString().padStart(4)}: ` : '';
+        colorized.push(this.colors.added(`+${lineNum}${line.substring(1)}`));
+        lineNumModified++;
+      } else if (line.startsWith('-')) {
+        const lineNum = showLineNumbers ? `${lineNumOriginal.toString().padStart(4)}: ` : '';
+        colorized.push(this.colors.removed(`-${lineNum}${line.substring(1)}`));
+        lineNumOriginal++;
+      } else if (line.startsWith(' ')) {
+        const lineNum = showLineNumbers ? 
+          `${lineNumOriginal.toString().padStart(4)}: ` : '';
+        colorized.push(this.colors.unchanged(` ${lineNum}${line.substring(1)}`));
+        lineNumOriginal++;
+        lineNumModified++;
+      } else {
+        colorized.push(this.colors.header(line));
+      }
+    }
+
+    return colorized.join('\n');
+  }
+
+  /**
+   * Generate impact summary from YAML diff
+   * @private
+   */
+  generateImpactSummary(yamlDiff) {
+    const impacts = [];
+
+    // Check for dependency changes
+    if (yamlDiff.sections.dependencies) {
+      const changes = yamlDiff.sections.dependencies.changes || [];
+      for (const change of changes) {
+        if (change.type === 'added') {
+          impacts.push(`New dependency added: ${change.items.join(', ')}`);
+        } else if (change.type === 'removed') {
+          impacts.push(`Dependency removed: ${change.items.join(', ')}`);
+        }
+      }
+    }
+
+    // Check for command changes
+    if (yamlDiff.sections.commands) {
+      impacts.push('Commands modified - users may need to update their workflows');
+    }
+
+    // Check for persona changes
+    if (yamlDiff.sections.persona) {
+      impacts.push('Agent persona modified - behavior may change');
+    }
+
+    return impacts;
+  }
+
+  /**
+   * Generate a side-by-side diff view
+   * @param {string} original - Original content
+   * @param {string} modified - Modified content
+   * @param {Object} options - Display options
+   * @returns {string} Side-by-side diff
+   */
+  generateSideBySideDiff(original, modified, options = {}) {
+    const { width = 80, gutter = 3 } = options;
+    const columnWidth = Math.floor((width - gutter) / 2);
+
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+    const maxLines = Math.max(originalLines.length, modifiedLines.length);
+
+    const output = [];
+    output.push(this.colors.header('─'.repeat(width)));
+    output.push(
+      this.colors.header('Original'.padEnd(columnWidth)) +
+      ' '.repeat(gutter) +
+      this.colors.header('Modified'.padEnd(columnWidth))
+    );
+    output.push(this.colors.header('─'.repeat(width)));
+
+    for (let i = 0; i < maxLines; i++) {
+      const origLine = (originalLines[i] || '').substring(0, columnWidth);
+      const modLine = (modifiedLines[i] || '').substring(0, columnWidth);
+
+      let coloredOrig = origLine.padEnd(columnWidth);
+      let coloredMod = modLine.padEnd(columnWidth);
+
+      if (origLine !== modLine) {
+        if (!originalLines[i]) {
+          coloredMod = this.colors.added(coloredMod);
+        } else if (!modifiedLines[i]) {
+          coloredOrig = this.colors.removed(coloredOrig);
+        } else {
+          coloredOrig = this.colors.removed(coloredOrig);
+          coloredMod = this.colors.added(coloredMod);
+        }
+      }
+
+      output.push(coloredOrig + ' '.repeat(gutter) + coloredMod);
+    }
+
+    output.push(this.colors.header('─'.repeat(width)));
+    return output.join('\n');
+  }
+}
+
+module.exports = DiffGenerator;