create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/greeting-config-cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Greeting Configuration CLI
+ *
+ * Standalone CLI for managing greeting preferences.
+ * Usage:
+ *   node .aiox-core/scripts/greeting-config-cli.js get greeting
+ *   node .aiox-core/scripts/greeting-config-cli.js set greeting.preference minimal
+ */
+
+const GreetingPreferenceManager = require('./greeting-preference-manager');
+
+const command = process.argv[2];
+const subcommand = process.argv[3];
+const value = process.argv[4];
+
+(async () => {
+  try {
+    const manager = new GreetingPreferenceManager();
+
+    switch (command) {
+      case 'get':
+        if (subcommand === 'greeting') {
+          const config = manager.getConfig();
+
+          console.log('📊 Agent Greeting Configuration\n');
+          console.log(`Preference: ${config.preference || 'auto'} (auto|minimal|named|archetypal)`);
+          console.log(`Context Detection: ${config.contextDetection !== false ? 'enabled' : 'disabled'}`);
+          console.log(`Session Detection: ${config.sessionDetection || 'hybrid'}`);
+          console.log(`Workflow Detection: ${config.workflowDetection || 'hardcoded'}`);
+          console.log(`Show Archetype: ${config.showArchetype !== false ? 'yes' : 'no'}`);
+          console.log(`Locale: ${config.locale || 'en-US'}`);
+
+          console.log('\n💡 Examples:');
+          console.log('  - "auto": Session-aware greetings (default)');
+          console.log('  - "minimal": Always minimal greeting');
+          console.log('  - "named": Always named greeting');
+          console.log('  - "archetypal": Always archetypal greeting');
+        } else {
+          console.error('Usage: node greeting-config-cli.js get greeting');
+          process.exit(1);
+        }
+        break;
+
+      case 'set':
+        if (subcommand === 'greeting.preference' && value) {
+          const result = manager.setPreference(value);
+          console.log(`✅ Greeting preference set to: ${result.preference}`);
+
+          if (value === 'auto') {
+            console.log('\n📌 Using automatic session-aware greetings:');
+            console.log('  - New session → Full greeting (archetypal level)');
+            console.log('  - Existing session → Quick greeting (named level)');
+            console.log('  - Workflow session → Minimal greeting + suggestions');
+          } else {
+            console.log(`\n📌 Using fixed level: ${value} for all sessions`);
+          }
+        } else {
+          console.error('Usage: node greeting-config-cli.js set greeting.preference <auto|minimal|named|archetypal>');
+          console.error('\nExamples:');
+          console.error('  node greeting-config-cli.js set greeting.preference auto');
+          console.error('  node greeting-config-cli.js set greeting.preference minimal');
+          process.exit(1);
+        }
+        break;
+
+      default:
+        console.log(`
+Usage:
+  node greeting-config-cli.js get greeting
+  node greeting-config-cli.js set greeting.preference <auto|minimal|named|archetypal>
+
+Examples:
+  node greeting-config-cli.js get greeting
+  node greeting-config-cli.js set greeting.preference auto
+  node greeting-config-cli.js set greeting.preference minimal
+        `);
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+})();
+

package/template/.aiox-core/development/scripts/greeting-preference-manager.js

@@ -0,0 +1,169 @@
+/**
+ * Greeting Preference Configuration Manager
+ *
+ * Manages user preferences for agent greeting personification levels.
+ * Integrates with GreetingBuilder (Story 6.1.2.5).
+ *
+ * Story ACT-2: Now accounts for user_profile — bob mode forces minimal/named.
+ *
+ * Performance: Preference check <5ms (called on every agent activation)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const CONFIG_PATH = path.join(process.cwd(), '.aiox-core', 'core-config.yaml');
+const BACKUP_PATH = path.join(process.cwd(), '.aiox-core', 'core-config.yaml.backup');
+const VALID_PREFERENCES = ['auto', 'minimal', 'named', 'archetypal'];
+
+// Bob mode restricts greeting to simpler levels (Story ACT-2)
+const BOB_MODE_ALLOWED_PREFERENCES = ['minimal', 'named'];
+const BOB_MODE_DEFAULT_PREFERENCE = 'named';
+
+class GreetingPreferenceManager {
+  /**
+   * Get current greeting preference, accounting for user_profile restrictions.
+   *
+   * Story ACT-2 - AC1: When user_profile === 'bob', forces preference to
+   * 'minimal' or 'named' regardless of what is configured. If the configured
+   * preference is 'auto' or 'archetypal', it falls back to BOB_MODE_DEFAULT_PREFERENCE.
+   *
+   * @param {string} [userProfile] - Optional user_profile override. If not provided, reads from config.
+   * @returns {string} Current preference (auto|minimal|named|archetypal)
+   */
+  getPreference(userProfile) {
+    try {
+      const config = this._loadConfig();
+      const rawPreference = config?.agentIdentity?.greeting?.preference || 'auto';
+
+      // Story ACT-2: If bob mode, restrict preference to minimal/named
+      const effectiveProfile = userProfile || config?.user_profile;
+      if (effectiveProfile === 'bob') {
+        if (BOB_MODE_ALLOWED_PREFERENCES.includes(rawPreference)) {
+          return rawPreference;
+        }
+        // Override non-allowed preferences (auto, archetypal) to bob default
+        return BOB_MODE_DEFAULT_PREFERENCE;
+      }
+
+      return rawPreference;
+    } catch (error) {
+      console.warn('[GreetingPreference] Failed to load, using default:', error.message);
+      return 'auto';
+    }
+  }
+
+  /**
+   * Set greeting preference
+   * @param {string} preference - New preference (auto|minimal|named|archetypal)
+   * @throws {Error} If preference is invalid
+   */
+  setPreference(preference) {
+    // Validate preference
+    if (!VALID_PREFERENCES.includes(preference)) {
+      const validOptions = VALID_PREFERENCES.join(', ');
+      throw new Error(
+        `Invalid preference: "${preference}". ` +
+        `Valid options: ${validOptions}. ` +
+        'Examples: "auto" (session-aware), "minimal" (always minimal), "named" (always named), "archetypal" (always archetypal)',
+      );
+    }
+
+    try {
+      // Backup existing config before modification
+      this._backupConfig();
+
+      const config = this._loadConfig();
+
+      // Ensure structure exists
+      if (!config.agentIdentity) config.agentIdentity = {};
+      if (!config.agentIdentity.greeting) config.agentIdentity.greeting = {};
+
+      // Set preference
+      config.agentIdentity.greeting.preference = preference;
+
+      // Validate YAML before write
+      const yamlContent = yaml.dump(config, { lineWidth: -1 });
+      try {
+        yaml.load(yamlContent); // Validate syntax
+      } catch (yamlError) {
+        this._restoreBackup();
+        throw new Error(`Invalid YAML generated: ${yamlError.message}`);
+      }
+
+      // Write back
+      this._saveConfig(config);
+
+      return { success: true, preference };
+    } catch (error) {
+      // Restore backup on error
+      this._restoreBackup();
+      throw new Error(`Failed to set preference: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get all greeting configuration
+   * @returns {Object} Complete greeting config
+   */
+  getConfig() {
+    try {
+      const config = this._loadConfig();
+      return config?.agentIdentity?.greeting || {};
+    } catch (error) {
+      console.warn('[GreetingPreference] Failed to load config, returning empty:', error.message);
+      return {};
+    }
+  }
+
+  /**
+   * Backup config file before modification
+   * @private
+   */
+  _backupConfig() {
+    try {
+      if (fs.existsSync(CONFIG_PATH)) {
+        fs.copyFileSync(CONFIG_PATH, BACKUP_PATH);
+      }
+    } catch (error) {
+      console.warn('[GreetingPreference] Failed to backup config:', error.message);
+    }
+  }
+
+  /**
+   * Restore config from backup
+   * @private
+   */
+  _restoreBackup() {
+    try {
+      if (fs.existsSync(BACKUP_PATH)) {
+        fs.copyFileSync(BACKUP_PATH, CONFIG_PATH);
+        console.log('[GreetingPreference] Config restored from backup');
+      }
+    } catch (error) {
+      console.error('[GreetingPreference] Failed to restore backup:', error.message);
+    }
+  }
+
+  /**
+   * Load config from YAML
+   * @private
+   */
+  _loadConfig() {
+    const content = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return yaml.load(content);
+  }
+
+  /**
+   * Save config to YAML
+   * @private
+   */
+  _saveConfig(config) {
+    const content = yaml.dump(config, { lineWidth: -1 });
+    fs.writeFileSync(CONFIG_PATH, content, 'utf8');
+  }
+}
+
+module.exports = GreetingPreferenceManager;
+

package/template/.aiox-core/development/scripts/issue-triage.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+/**
+ * Issue Triage Script
+ * Batch triage tool for @devops to manage GitHub issues.
+ *
+ * Usage:
+ *   node issue-triage.js --list                     # List untriaged issues
+ *   node issue-triage.js --apply 174 --type bug --priority P2 --area installer
+ *   node issue-triage.js --report                   # Generate triage summary
+ *
+ * Story: GHIM-001
+ */
+
+const { execSync } = require('child_process');
+
+const VALID_TYPES = ['bug', 'feature', 'enhancement', 'docs', 'test', 'chore'];
+const VALID_PRIORITIES = ['P1', 'P2', 'P3', 'P4'];
+const VALID_AREAS = ['core', 'installer', 'synapse', 'cli', 'pro', 'health-check', 'docs', 'devops', 'agents', 'workflows'];
+
+function gh(cmd) {
+  try {
+    return execSync(`gh ${cmd}`, { encoding: 'utf8', timeout: 60000 });
+  } catch (err) {
+    console.error(`gh command failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function listUntriaged() {
+  const raw = gh('issue list --label "status: needs-triage" --json number,title,labels,createdAt,author --limit 100');
+  const issues = JSON.parse(raw);
+
+  if (issues.length === 0) {
+    console.log('No untriaged issues found.');
+    return;
+  }
+
+  console.log(`\n=== ${issues.length} Untriaged Issues ===\n`);
+  for (const issue of issues) {
+    const labels = issue.labels.map(l => l.name).join(', ');
+    const date = issue.createdAt.split('T')[0];
+    console.log(`  #${issue.number} [${date}] ${issue.title}`);
+    console.log(`    Author: ${issue.author.login} | Labels: ${labels}`);
+    console.log();
+  }
+}
+
+function applyLabels(number, type, priority, areas, extra) {
+  if (!VALID_TYPES.includes(type)) {
+    console.error(`Invalid type: ${type}. Valid: ${VALID_TYPES.join(', ')}`);
+    process.exit(1);
+  }
+  if (!VALID_PRIORITIES.includes(priority)) {
+    console.error(`Invalid priority: ${priority}. Valid: ${VALID_PRIORITIES.join(', ')}`);
+    process.exit(1);
+  }
+
+  const addLabels = [`type: ${type}`, `priority: ${priority}`, 'status: confirmed'];
+  for (const area of areas) {
+    if (!VALID_AREAS.includes(area)) {
+      console.error(`Invalid area: ${area}. Valid: ${VALID_AREAS.join(', ')}`);
+      process.exit(1);
+    }
+    addLabels.push(`area: ${area}`);
+  }
+  if (extra) {
+    addLabels.push(...extra);
+  }
+
+  const addStr = addLabels.map(l => `"${l}"`).join(',');
+  console.log(`Applying to #${number}: ${addLabels.join(', ')}`);
+  gh(`issue edit ${number} --add-label ${addStr} --remove-label "status: needs-triage"`);
+  console.log(`  Done.`);
+}
+
+function generateReport() {
+  const raw = gh('issue list --state open --json number,title,labels --limit 200');
+  const issues = JSON.parse(raw);
+
+  const stats = {
+    total: issues.length,
+    untriaged: 0,
+    byType: {},
+    byPriority: {},
+    byArea: {},
+    byStatus: {}
+  };
+
+  for (const issue of issues) {
+    const labels = issue.labels.map(l => l.name);
+
+    if (labels.includes('status: needs-triage')) stats.untriaged++;
+
+    for (const label of labels) {
+      if (label.startsWith('type: ')) {
+        const val = label.replace('type: ', '');
+        stats.byType[val] = (stats.byType[val] || 0) + 1;
+      }
+      if (label.startsWith('priority: ')) {
+        const val = label.replace('priority: ', '');
+        stats.byPriority[val] = (stats.byPriority[val] || 0) + 1;
+      }
+      if (label.startsWith('area: ')) {
+        const val = label.replace('area: ', '');
+        stats.byArea[val] = (stats.byArea[val] || 0) + 1;
+      }
+      if (label.startsWith('status: ')) {
+        const val = label.replace('status: ', '');
+        stats.byStatus[val] = (stats.byStatus[val] || 0) + 1;
+      }
+    }
+  }
+
+  console.log('\n=== Issue Triage Report ===\n');
+  console.log(`Total open issues: ${stats.total}`);
+  console.log(`Untriaged: ${stats.untriaged}`);
+  console.log(`\nBy Type:`);
+  for (const [k, v] of Object.entries(stats.byType).sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${k}: ${v}`);
+  }
+  console.log(`\nBy Priority:`);
+  for (const [k, v] of Object.entries(stats.byPriority).sort()) {
+    console.log(`  ${k}: ${v}`);
+  }
+  console.log(`\nBy Area:`);
+  for (const [k, v] of Object.entries(stats.byArea).sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${k}: ${v}`);
+  }
+  console.log(`\nBy Status:`);
+  for (const [k, v] of Object.entries(stats.byStatus).sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${k}: ${v}`);
+  }
+}
+
+// CLI argument parsing
+const args = process.argv.slice(2);
+
+if (args.includes('--list')) {
+  listUntriaged();
+} else if (args.includes('--apply')) {
+  const idx = args.indexOf('--apply');
+  const number = parseInt(args[idx + 1]);
+  const typeIdx = args.indexOf('--type');
+  const prioIdx = args.indexOf('--priority');
+  const areaIdx = args.indexOf('--area');
+  const extraIdx = args.indexOf('--extra');
+
+  if (!number || typeIdx === -1 || prioIdx === -1 || areaIdx === -1) {
+    console.error('Usage: --apply <number> --type <type> --priority <P1-P4> --area <area> [--extra "label1,label2"]');
+    process.exit(1);
+  }
+
+  const type = args[typeIdx + 1];
+  const priority = args[prioIdx + 1];
+  const areas = args[areaIdx + 1].split(',');
+  const extra = extraIdx !== -1 ? args[extraIdx + 1].split(',') : [];
+
+  applyLabels(number, type, priority, areas, extra);
+} else if (args.includes('--report')) {
+  generateReport();
+} else {
+  console.log('Issue Triage Tool (GHIM-001)\n');
+  console.log('Usage:');
+  console.log('  --list                                    List untriaged issues');
+  console.log('  --apply <#> --type <t> --priority <P> --area <a>  Apply labels');
+  console.log('  --report                                  Generate triage summary');
+  console.log('\nTypes:', VALID_TYPES.join(', '));
+  console.log('Priorities:', VALID_PRIORITIES.join(', '));
+  console.log('Areas:', VALID_AREAS.join(', '));
+}

package/template/.aiox-core/development/scripts/manifest-preview.js

@@ -0,0 +1,245 @@
+/**
+ * Manifest Preview Utility
+ * Shows diff view for manifest updates
+ * @module manifest-preview
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const ComponentPreview = require('./component-preview');
+const chalk = require('chalk');
+
+class ManifestPreview {
+  constructor(rootPath) {
+    this.rootPath = rootPath || process.cwd();
+    this.manifestPath = path.join(this.rootPath, 'aiox-core', 'team-manifest.yaml');
+    this.componentPreview = new ComponentPreview();
+  }
+
+  /**
+   * Preview manifest update for a new component
+   * @param {string} componentType - Type of component
+   * @param {Object} componentInfo - Component information
+   * @returns {Promise<Object>} Preview result with diff
+   */
+  async previewManifestUpdate(componentType, componentInfo) {
+    try {
+      // Read current manifest
+      const currentContent = await fs.readFile(this.manifestPath, 'utf8');
+      const manifest = yaml.load(currentContent);
+      
+      // Create updated manifest
+      const updatedManifest = this.addComponentToManifest(manifest, componentType, componentInfo);
+      const updatedContent = yaml.dump(updatedManifest, {
+        styles: {
+          '!!null': 'canonical'
+        },
+        sortKeys: false
+      });
+      
+      // Generate diff preview
+      const diff = this.componentPreview.generateManifestDiff(currentContent, updatedContent);
+      
+      return {
+        success: true,
+        diff,
+        currentContent,
+        updatedContent,
+        changes: this.summarizeChanges(manifest, updatedManifest)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Add component to manifest structure
+   * @private
+   */
+  addComponentToManifest(manifest, componentType, componentInfo) {
+    const updated = JSON.parse(JSON.stringify(manifest)); // Deep clone
+    
+    switch (componentType) {
+      case 'agent':
+        if (!updated.team) updated.team = {};
+        if (!updated.team.agents) updated.team.agents = [];
+        
+        // Check if agent already exists
+        const existingAgentIndex = updated.team.agents.findIndex(
+          a => a.id === componentInfo.id
+        );
+        
+        if (existingAgentIndex >= 0) {
+          // Update existing
+          updated.team.agents[existingAgentIndex] = {
+            id: componentInfo.id,
+            path: `agents/${componentInfo.id}.md`,
+            name: componentInfo.name || componentInfo.id,
+            ...(componentInfo.description && { description: componentInfo.description })
+          };
+        } else {
+          // Add new
+          updated.team.agents.push({
+            id: componentInfo.id,
+            path: `agents/${componentInfo.id}.md`,
+            name: componentInfo.name || componentInfo.id,
+            ...(componentInfo.description && { description: componentInfo.description })
+          });
+        }
+        break;
+        
+      case 'workflow':
+        if (!updated.workflows) updated.workflows = [];
+        
+        const existingWorkflowIndex = updated.workflows.findIndex(
+          w => w.id === componentInfo.id
+        );
+        
+        if (existingWorkflowIndex >= 0) {
+          updated.workflows[existingWorkflowIndex] = {
+            id: componentInfo.id,
+            path: `workflows/${componentInfo.id}.yaml`,
+            name: componentInfo.name || componentInfo.id,
+            type: componentInfo.type || 'standard',
+            ...(componentInfo.description && { description: componentInfo.description })
+          };
+        } else {
+          updated.workflows.push({
+            id: componentInfo.id,
+            path: `workflows/${componentInfo.id}.yaml`,
+            name: componentInfo.name || componentInfo.id,
+            type: componentInfo.type || 'standard',
+            ...(componentInfo.description && { description: componentInfo.description })
+          });
+        }
+        break;
+    }
+    
+    // Update metadata
+    if (!updated.metadata) updated.metadata = {};
+    updated.metadata.lastUpdated = new Date().toISOString();
+    updated.metadata.version = this.incrementVersion(updated.metadata.version || '1.0.0');
+    
+    return updated;
+  }
+
+  /**
+   * Increment semantic version
+   * @private
+   */
+  incrementVersion(version) {
+    const parts = version.split('.');
+    parts[2] = String(parseInt(parts[2] || '0') + 1);
+    return parts.join('.');
+  }
+
+  /**
+   * Summarize changes made to manifest
+   * @private
+   */
+  summarizeChanges(oldManifest, newManifest) {
+    const changes = [];
+    
+    // Check agents
+    const oldAgents = oldManifest.team?.agents || [];
+    const newAgents = newManifest.team?.agents || [];
+    
+    if (newAgents.length > oldAgents.length) {
+      const added = newAgents.slice(oldAgents.length);
+      added.forEach(agent => {
+        changes.push({
+          type: 'added',
+          category: 'agent',
+          item: agent.id
+        });
+      });
+    }
+    
+    // Check workflows
+    const oldWorkflows = oldManifest.workflows || [];
+    const newWorkflows = newManifest.workflows || [];
+    
+    if (newWorkflows.length > oldWorkflows.length) {
+      const added = newWorkflows.slice(oldWorkflows.length);
+      added.forEach(workflow => {
+        changes.push({
+          type: 'added',
+          category: 'workflow',
+          item: workflow.id
+        });
+      });
+    }
+    
+    // Version change
+    if (oldManifest.metadata?.version !== newManifest.metadata?.version) {
+      changes.push({
+        type: 'updated',
+        category: 'version',
+        from: oldManifest.metadata?.version || '1.0.0',
+        to: newManifest.metadata?.version
+      });
+    }
+    
+    return changes;
+  }
+
+  /**
+   * Apply manifest update after preview
+   * @param {string} updatedContent - New manifest content
+   */
+  async applyManifestUpdate(updatedContent) {
+    await fs.writeFile(this.manifestPath, updatedContent, 'utf8');
+  }
+
+  /**
+   * Show interactive manifest update prompt
+   * @param {string} componentType - Type of component
+   * @param {Object} componentInfo - Component information
+   * @returns {Promise<boolean>} Whether update was applied
+   */
+  async interactiveManifestUpdate(componentType, componentInfo) {
+    const preview = await this.previewManifestUpdate(componentType, componentInfo);
+    
+    if (!preview.success) {
+      console.log(chalk.red(`\n❌ Failed to preview manifest update: ${preview.error}`));
+      return false;
+    }
+    
+    // Show diff
+    console.log(preview.diff);
+    
+    // Show change summary
+    console.log(chalk.cyan('\n📋 Summary of changes:'));
+    preview.changes.forEach(change => {
+      if (change.type === 'added') {
+        console.log(chalk.green(`  + Added ${change.category}: ${change.item}`));
+      } else if (change.type === 'updated') {
+        console.log(chalk.yellow(`  ~ Updated ${change.category}: ${change.from} → ${change.to}`));
+      }
+    });
+    
+    // Confirm update
+    const inquirer = require('inquirer');
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Apply these changes to team-manifest.yaml?',
+      default: true
+    }]);
+    
+    if (confirm) {
+      await this.applyManifestUpdate(preview.updatedContent);
+      console.log(chalk.green('\n✅ Manifest updated successfully!'));
+      return true;
+    }
+    
+    console.log(chalk.yellow('\n⚠️  Manifest update cancelled'));
+    return false;
+  }
+}
+
+module.exports = ManifestPreview;