aios-core 2.1.0

package/.aios-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 .aios-core/scripts/greeting-config-cli.js get greeting
+ *   node .aios-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/.aios-core/development/scripts/greeting-preference-manager.js

@@ -0,0 +1,145 @@
+/**
+ * Greeting Preference Configuration Manager
+ *
+ * Manages user preferences for agent greeting personification levels.
+ * Integrates with GreetingBuilder (Story 6.1.2.5).
+ *
+ * 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(), '.aios-core', 'core-config.yaml');
+const BACKUP_PATH = path.join(process.cwd(), '.aios-core', 'core-config.yaml.backup');
+const VALID_PREFERENCES = ['auto', 'minimal', 'named', 'archetypal'];
+
+class GreetingPreferenceManager {
+  /**
+   * Get current greeting preference
+   * @returns {string} Current preference (auto|minimal|named|archetypal)
+   */
+  getPreference() {
+    try {
+      const config = this._loadConfig();
+      return config?.agentIdentity?.greeting?.preference || 'auto';
+    } 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/.aios-core/development/scripts/migrate-task-to-v2.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+
+/**
+ * Task Migration Helper - V1.0 to V2.0
+ * 
+ * Semi-automated migration helper that adds missing V2.0 sections to tasks.
+ * Requires manual review and content filling.
+ * 
+ * Usage:
+ *   node migrate-task-to-v2.js <task-file>     # Migrate single task
+ * 
+ * Process:
+ *   1. Reads existing task
+ *   2. Identifies missing V2.0 sections
+ *   3. Adds section templates with TODO markers
+ *   4. Creates backup of original
+ *   5. Saves migrated version
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m',
+};
+
+/**
+ * V2.0 Section Templates
+ */
+const sectionTemplates = {
+  executionModes: `## Execution Modes
+
+**Choose your execution mode:**
+
+### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
+- Autonomous decision making with logging
+- Minimal user interaction
+- **Best for:** Simple, deterministic tasks
+
+### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
+- Explicit decision checkpoints
+- Educational explanations
+- **Best for:** Learning, complex decisions
+
+### 3. Pre-Flight Planning - Comprehensive Upfront Planning
+- Task analysis phase (identify all ambiguities)
+- Zero ambiguity execution
+- **Best for:** Ambiguous requirements, critical work
+
+**Parameter:** \`mode\` (optional, default: \`interactive\`)
+
+---
+`,
+
+  taskDefinition: `## Task Definition (AIOS Task Format V1.0)
+
+\`\`\`yaml
+task: {TODO: task identifier}
+responsável: {TODO: Agent Name}
+responsavel_type: Agente
+atomic_layer: {TODO: Atom|Molecule|Organism}
+
+**Entrada:**
+- campo: {TODO: fieldName}
+  tipo: {TODO: string|number|boolean}
+  origem: {TODO: User Input | config | Step X}
+  obrigatório: true
+  validação: {TODO: validation rule}
+
+**Saída:**
+- campo: {TODO: fieldName}
+  tipo: {TODO: type}
+  destino: {TODO: output | state | Step Y}
+  persistido: true
+\`\`\`
+
+---
+`,
+
+  preConditions: `## Pre-Conditions
+
+**Purpose:** Validate prerequisites BEFORE task execution (blocking)
+
+**Checklist:**
+
+\`\`\`yaml
+pre-conditions:
+  - [ ] {TODO: condition description}
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      {TODO: validation logic}
+    error_message: "{TODO: error message}"
+\`\`\`
+
+---
+`,
+
+  postConditions: `## Post-Conditions
+
+**Purpose:** Validate execution success AFTER task completes
+
+**Checklist:**
+
+\`\`\`yaml
+post-conditions:
+  - [ ] {TODO: verification step}
+    tipo: post-condition
+    blocker: true
+    validação: |
+      {TODO: validation logic}
+    error_message: "{TODO: error message}"
+\`\`\`
+
+---
+`,
+
+  acceptanceCriteria: `## Acceptance Criteria
+
+**Purpose:** Definitive pass/fail criteria for task completion
+
+**Checklist:**
+
+\`\`\`yaml
+acceptance-criteria:
+  - [ ] {TODO: acceptance criterion}
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      {TODO: validation logic}
+    error_message: "{TODO: error message}"
+\`\`\`
+
+---
+`,
+
+  tools: `## Tools
+
+**External/shared resources used by this task:**
+
+- **Tool:** N/A
+  - **Purpose:** {TODO: what this tool does}
+  - **Source:** {TODO: where to find it}
+
+---
+`,
+
+  scripts: `## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** N/A
+  - **Purpose:** {TODO: what this script does}
+  - **Language:** {TODO: JavaScript | Python | Bash}
+  - **Location:** {TODO: file path}
+
+---
+`,
+
+  errorHandling: `## Error Handling
+
+**Strategy:** {TODO: Fail-fast | Graceful degradation | Retry with backoff}
+
+**Common Errors:**
+
+1. **Error:** {TODO: error type}
+   - **Cause:** {TODO: why it happens}
+   - **Resolution:** {TODO: how to fix}
+   - **Recovery:** {TODO: automated recovery steps}
+
+---
+`,
+
+  performance: `## Performance
+
+**Expected Metrics:**
+
+\`\`\`yaml
+duration_expected: {TODO: X minutes}
+cost_estimated: {TODO: $X}
+token_usage: {TODO: ~X tokens}
+\`\`\`
+
+**Optimization Notes:**
+- {TODO: performance tips}
+
+---
+`,
+
+  metadata: `## Metadata
+
+\`\`\`yaml
+story: {TODO: Story ID or N/A}
+version: 1.0.0
+dependencies:
+  - {TODO: dependency file or N/A}
+tags:
+  - {TODO: tag1}
+  - {TODO: tag2}
+updated_at: ${new Date().toISOString().split('T')[0]}
+\`\`\`
+
+---
+`,
+};
+
+/**
+ * Check which sections are missing in the task
+ */
+function analyzeMissingSections(content) {
+  const checks = {
+    executionModes: !content.includes('## Execution Modes') && !content.includes('# Execution Modes'),
+    taskDefinition: !(content.includes('responsável:') && content.includes('atomic_layer:')),
+    entrada: !content.includes('**Entrada:**'),
+    saida: !content.includes('**Saída:**'),
+    preConditions: !content.includes('pre-conditions:'),
+    postConditions: !content.includes('post-conditions:'),
+    acceptanceCriteria: !content.includes('acceptance-criteria:'),
+    tools: !(content.includes('## Tools') || content.includes('**Tools:**')),
+    scripts: !(content.includes('## Scripts') || content.includes('**Scripts:**')),
+    errorHandling: !(content.includes('## Error Handling') && content.includes('strategy:')),
+    performance: !(content.includes('duration_expected:') && content.includes('cost_estimated:')),
+    metadata: !(content.includes('## Metadata') && content.includes('story:') && content.includes('version:')),
+  };
+
+  return checks;
+}
+
+/**
+ * Migrate a task file to V2.0 format
+ */
+function migrateTask(filePath) {
+  const fileName = path.basename(filePath);
+  
+  console.log(`${colors.cyan}📝 Migrating: ${fileName}${colors.reset}\n`);
+
+  // Read original file
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  // Analyze missing sections
+  const missing = analyzeMissingSections(content);
+  const missingSections = Object.keys(missing).filter(k => missing[k]);
+
+  if (missingSections.length === 0) {
+    console.log(`${colors.green}✅ Task already V2.0 compliant!${colors.reset}\n`);
+    return;
+  }
+
+  console.log(`${colors.yellow}Missing sections (${missingSections.length}):${colors.reset}`);
+  missingSections.forEach(section => {
+    console.log(`   - ${section}`);
+  });
+  console.log();
+
+  // Create backup
+  const backupPath = filePath.replace('.md', '.v1-backup.md');
+  fs.writeFileSync(backupPath, content, 'utf8');
+  console.log(`${colors.green}✅ Backup created: ${path.basename(backupPath)}${colors.reset}`);
+
+  // Build migrated content
+  let migratedContent = content;
+
+  // Find insertion point (usually after Purpose or first major section)
+  const purposeIndex = content.indexOf('## Purpose');
+  const insertionPoint = purposeIndex !== -1 
+    ? content.indexOf('\n---\n', purposeIndex) + 5
+    : content.indexOf('\n##', 100); // Fallback: after first heading
+
+  if (insertionPoint === -1 || insertionPoint === 4) {
+    console.log(`${colors.yellow}⚠ Could not find insertion point. Adding sections at end.${colors.reset}`);
+  }
+
+  // Add missing sections
+  let sectionsToAdd = '\n';
+  
+  if (missing.executionModes) {
+    sectionsToAdd += sectionTemplates.executionModes + '\n';
+  }
+  
+  if (missing.taskDefinition || missing.entrada || missing.saida) {
+    sectionsToAdd += sectionTemplates.taskDefinition + '\n';
+  }
+  
+  if (missing.preConditions) {
+    sectionsToAdd += sectionTemplates.preConditions + '\n';
+  }
+  
+  if (missing.postConditions) {
+    sectionsToAdd += sectionTemplates.postConditions + '\n';
+  }
+  
+  if (missing.acceptanceCriteria) {
+    sectionsToAdd += sectionTemplates.acceptanceCriteria + '\n';
+  }
+  
+  if (missing.tools) {
+    sectionsToAdd += sectionTemplates.tools + '\n';
+  }
+  
+  if (missing.scripts) {
+    sectionsToAdd += sectionTemplates.scripts + '\n';
+  }
+  
+  if (missing.errorHandling) {
+    sectionsToAdd += sectionTemplates.errorHandling + '\n';
+  }
+  
+  if (missing.performance) {
+    sectionsToAdd += sectionTemplates.performance + '\n';
+  }
+  
+  if (missing.metadata) {
+    sectionsToAdd += sectionTemplates.metadata + '\n';
+  }
+
+  // Insert sections
+  if (insertionPoint > 0) {
+    migratedContent = 
+      content.substring(0, insertionPoint) +
+      sectionsToAdd +
+      content.substring(insertionPoint);
+  } else {
+    migratedContent = content + '\n' + sectionsToAdd;
+  }
+
+  // Save migrated file
+  fs.writeFileSync(filePath, migratedContent, 'utf8');
+  console.log(`${colors.green}✅ Migration complete: ${fileName}${colors.reset}`);
+  console.log(`${colors.yellow}⚠ IMPORTANT: Review and fill TODO markers${colors.reset}\n`);
+
+  // Run validation
+  console.log(`${colors.cyan}🔍 Validating migrated task...${colors.reset}`);
+  const validatePath = path.join(__dirname, 'validate-task-v2.js');
+  const { execSync } = require('child_process');
+  
+  try {
+    execSync(`node "${validatePath}" "${filePath}"`, { stdio: 'inherit' });
+  } catch (error) {
+    // Validation failed - expected for TODOs
+    console.log(`${colors.yellow}⚠ Validation failed - fill TODOs and re-validate${colors.reset}\n`);
+  }
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Usage: node migrate-task-to-v2.js <task-file>');
+    console.log('');
+    console.log('Example:');
+    console.log('  node migrate-task-to-v2.js .aios-core/tasks/dev-develop-story.md');
+    process.exit(0);
+  }
+
+  const taskFile = args[0];
+  
+  if (!fs.existsSync(taskFile)) {
+    console.error(`${colors.yellow}✗ File not found: ${taskFile}${colors.reset}`);
+    process.exit(2);
+  }
+
+  migrateTask(taskFile);
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { migrateTask, analyzeMissingSections };
+