aether-colony 5.0.0 → 5.2.1

package/bin/generate-commands.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+/**
+ * YAML Command Generator
+ *
+ * Reads YAML source files from .aether/commands/ and generates
+ * both Claude Code and OpenCode command markdown files.
+ *
+ * Usage:
+ *   node bin/generate-commands.js          # Generate all command files
+ *   node bin/generate-commands.js --check  # Check if generated files are up-to-date
+ *
+ * @module bin/generate-commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const YAML_DIR = path.join(__dirname, '..', '.aether', 'commands');
+const CLAUDE_DIR = path.join(__dirname, '..', '.claude', 'commands', 'ant');
+const OPENCODE_DIR = path.join(__dirname, '..', '.opencode', 'commands', 'ant');
+
+const NORMALIZE_PREAMBLE = `### Step -1: Normalize Arguments
+
+Run: \`normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")\`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use \`$normalized_args\` throughout this command.
+
+`;
+
+/**
+ * Generate a command markdown file for a specific provider.
+ *
+ * @param {object} spec - Parsed YAML command spec
+ * @param {string} spec.name - Command name (e.g., "ant:focus")
+ * @param {string} spec.description - Shared description
+ * @param {string} [spec.description_claude] - Claude-specific description
+ * @param {string} [spec.description_opencode] - OpenCode-specific description
+ * @param {string} [spec.body] - Shared command body with template markers
+ * @param {string} [spec.body_claude] - Claude-specific body (skips template processing)
+ * @param {string} [spec.body_opencode] - OpenCode-specific body (skips template processing)
+ * @param {string} provider - Target provider: 'claude' or 'opencode'
+ * @returns {string} Generated markdown content
+ */
+function generateForProvider(spec, provider) {
+  // 1. Description: use provider-specific if available
+  var desc = spec['description_' + provider] || spec.description;
+
+  // 2. Build frontmatter
+  var output = '---\nname: ' + spec.name + '\ndescription: "' + desc + '"\n---\n\n';
+
+  // 3. Header comment
+  var yamlFilename = spec.name.replace('ant:', '') + '.yaml';
+  output = '<!-- Generated from .aether/commands/' + yamlFilename + ' - DO NOT EDIT DIRECTLY -->\n' + output;
+
+  // 4. Determine body source
+  var providerBody = spec['body_' + provider];
+  var body;
+
+  if (providerBody) {
+    // Provider-specific body -- use directly, no template processing
+    body = providerBody;
+  } else if (spec.body) {
+    // Shared body -- apply template processing
+    body = spec.body;
+
+    // Replace {{ARGUMENTS}}
+    if (provider === 'claude') {
+      body = body.replace(/\{\{ARGUMENTS\}\}/g, '$ARGUMENTS');
+    } else {
+      body = body.replace(/\{\{ARGUMENTS\}\}/g, '$normalized_args');
+    }
+
+    // Replace {{TOOL_PREFIX "..."}}
+    if (provider === 'claude') {
+      body = body.replace(/\{\{TOOL_PREFIX "(.+?)"\}\}/g, 'Run using the Bash tool with description "$1":');
+    } else {
+      body = body.replace(/\{\{TOOL_PREFIX "(.+?)"\}\}/g, 'Run:');
+    }
+
+    // Strip opposite-provider blocks
+    var opposite = provider === 'claude' ? 'opencode' : 'claude';
+    var stripRegex = new RegExp('\\{\\{#' + opposite + '\\}\\}[\\s\\S]*?\\{\\{/' + opposite + '\\}\\}', 'g');
+    body = body.replace(stripRegex, '');
+
+    // Keep same-provider blocks (unwrap markers)
+    var keepRegex = new RegExp('\\{\\{#' + provider + '\\}\\}([\\s\\S]*?)\\{\\{/' + provider + '\\}\\}', 'g');
+    body = body.replace(keepRegex, '$1');
+  } else {
+    throw new Error('Command "' + spec.name + '" has no body field and no body_' + provider + ' field');
+  }
+
+  // 5. Inject normalize-args preamble for OpenCode
+  if (provider === 'opencode') {
+    output += NORMALIZE_PREAMBLE;
+  }
+
+  output += body;
+  return output;
+}
+
+/**
+ * Main function: read YAML sources, generate command files for both providers.
+ */
+function main() {
+  var checkMode = process.argv.includes('--check');
+
+  // Ensure YAML source directory exists
+  if (!fs.existsSync(YAML_DIR)) {
+    console.log('No YAML source directory found at ' + YAML_DIR);
+    console.log('Run YAML conversion first to create .aether/commands/*.yaml files.');
+    process.exit(0);
+  }
+
+  // Read all YAML files
+  var yamlFiles = fs.readdirSync(YAML_DIR).filter(function (f) {
+    return f.endsWith('.yaml');
+  });
+
+  if (yamlFiles.length === 0) {
+    console.log('No .yaml files found in ' + YAML_DIR);
+    process.exit(0);
+  }
+
+  var mismatches = [];
+  var generated = 0;
+
+  yamlFiles.forEach(function (filename) {
+    var filePath = path.join(YAML_DIR, filename);
+    var content = fs.readFileSync(filePath, 'utf8');
+    var spec = yaml.load(content);
+    var outputName = filename.replace('.yaml', '.md');
+
+    var providers = [
+      { name: 'claude', dir: CLAUDE_DIR },
+      { name: 'opencode', dir: OPENCODE_DIR }
+    ];
+
+    providers.forEach(function (prov) {
+      var output = generateForProvider(spec, prov.name);
+      var outputPath = path.join(prov.dir, outputName);
+
+      if (checkMode) {
+        // Compare with existing file
+        if (fs.existsSync(outputPath)) {
+          var existing = fs.readFileSync(outputPath, 'utf8');
+          if (existing !== output) {
+            mismatches.push(outputPath);
+          }
+        } else {
+          mismatches.push(outputPath + ' (missing)');
+        }
+      } else {
+        // Ensure output directory exists
+        if (!fs.existsSync(prov.dir)) {
+          fs.mkdirSync(prov.dir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, output);
+        generated++;
+      }
+    });
+  });
+
+  if (checkMode) {
+    if (mismatches.length > 0) {
+      console.log('Generated files are out of date:');
+      mismatches.forEach(function (m) {
+        console.log('  ' + m);
+      });
+      console.log('\nRun "node bin/generate-commands.js" to regenerate.');
+      process.exit(1);
+    } else {
+      console.log('All generated files are up to date. (' + yamlFiles.length + ' YAML sources checked)');
+      process.exit(0);
+    }
+  } else {
+    console.log('Generated ' + generated + ' command files from ' + yamlFiles.length + ' YAML sources.');
+  }
+}
+
+module.exports = { generateForProvider };
+
+if (require.main === module) {
+  main();
+}

package/bin/generate-commands.sh

@@ -1,17 +1,16 @@
 #!/bin/bash
-# generate-commands.sh - Sync commands between Claude Code and OpenCode
+# generate-commands.sh - Validate YAML source -> generated command file sync
 #
-# This script helps keep commands in sync between the two platforms.
-# Currently it provides a simple diff-based sync, with plans for full
-# YAML-based generation in the future.
+# This script validates that generated .md files (.claude/commands/ant/*.md and
+# .opencode/commands/ant/*.md) match the output from YAML sources (.aether/commands/*.yaml).
 #
 # Usage:
-#   ./bin/generate-commands.sh [check|sync|diff]
+#   ./bin/generate-commands.sh [check|diff|help]
 #
 # Commands:
-#   check  - Check if commands are in sync (exit 1 if not)
-#   sync   - Copy Claude Code commands to OpenCode (with tool name translation)
+#   check  - Validate generated files match YAML sources
 #   diff   - Show differences between command sets
+#   help   - Show this help message
 
 set -e
 
@@ -20,6 +19,9 @@ PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
 
 CLAUDE_DIR="$PROJECT_DIR/.claude/commands/ant"
 OPENCODE_DIR="$PROJECT_DIR/.opencode/commands/ant"
+CLAUDE_AGENT_DIR="$PROJECT_DIR/.claude/agents/ant"
+OPENCODE_AGENT_DIR="$PROJECT_DIR/.opencode/agents"
+AETHER_AGENT_MIRROR_DIR="$PROJECT_DIR/.aether/agents-claude"
 
 # Colors for output
 RED='\033[0;31m'
@@ -86,6 +88,14 @@ list_commands() {
     fi
 }
 
+# List agent definition files (*.md) by basename
+list_agents() {
+    local dir="$1"
+    if [[ -d "$dir" ]]; then
+        find "$dir" -name "*.md" -type f -exec basename {} \; | sort
+    fi
+}
+
 # Check if directories are in sync (by file count and names)
 check_sync() {
     log_info "Checking command sync status..."
@@ -133,95 +143,110 @@ check_sync() {
     return 0
 }
 
-# Check content-level sync using checksums (Pass 2)
-# Compares each matching file pair by SHA-1 hash and reports diffs
-check_content() {
-    log_info "Checking content-level sync (checksums)..."
+# Check YAML generation sync (Pass 2)
+# Validates that generated .md files match YAML sources
+check_yaml_generation() {
+    log_info "Checking YAML generation sync..."
 
-    local drift_count=0
-    local error_count=0
-    local match_count=0
-    local drift_files=""
-    local error_files=""
+    # Verify YAML source directory exists
+    local yaml_dir="$PROJECT_DIR/.aether/commands"
+    if [[ ! -d "$yaml_dir" ]]; then
+        log_error "YAML source directory not found: $yaml_dir"
+        return 1
+    fi
 
-    # Use null delimiter for safe iteration (handles filenames with spaces)
-    while IFS= read -r -d '' claude_file; do
-        local file
-        file=$(basename "$claude_file")
-        local opencode_file="$OPENCODE_DIR/$file"
+    local yaml_count
+    yaml_count=$(find "$yaml_dir" -name "*.yaml" | wc -l | tr -d ' ')
+    if [[ "$yaml_count" -eq 0 ]]; then
+        log_error "No YAML source files found in $yaml_dir"
+        return 1
+    fi
 
-        # Skip if OpenCode file doesn't exist (already caught by Pass 1)
-        if [[ ! -f "$opencode_file" ]]; then
-            continue
-        fi
+    log_info "Found $yaml_count YAML source files"
 
-        # Compute hashes with error handling
-        local claude_hash opencode_hash
-        claude_hash=$(compute_hash "$claude_file")
-        if [[ $? -ne 0 ]]; then
-            log_error "Cannot hash $claude_file ($claude_hash)"
-            error_files="${error_files}  ${file} (${claude_hash})\n"
-            error_count=$((error_count + 1))
-            continue
-        fi
+    # Run generator in check mode
+    if node "$PROJECT_DIR/bin/generate-commands.js" --check; then
+        log_info "Generated files match YAML sources ($yaml_count commands)"
+        return 0
+    else
+        log_error "Generated files are out of date. Run 'npm run generate' to update."
+        return 1
+    fi
+}
 
-        opencode_hash=$(compute_hash "$opencode_file")
-        if [[ $? -ne 0 ]]; then
-            log_error "Cannot hash $opencode_file ($opencode_hash)"
-            error_files="${error_files}  ${file} (${opencode_hash})\n"
-            error_count=$((error_count + 1))
-            continue
-        fi
+# Check agent sync strategy:
+# 1) Claude <-> OpenCode: structural parity (count + file names)
+# 2) Claude <-> .aether mirror: exact parity (count + names + content hash)
+check_agent_sync() {
+    log_info "Checking agent sync status..."
 
-        if [[ "$claude_hash" != "$opencode_hash" ]]; then
-            drift_count=$((drift_count + 1))
-            drift_files="${drift_files}  ${file}\n"
-
-            log_warn "Content drift: $file"
-            echo "  Claude:  $claude_hash"
-            echo "  OpenCode: $opencode_hash"
-
-            # PLAN-006 fix #12 - improved diff error handling
-            echo "  ---"
-            local diff_output
-            if diff_output=$(diff -u "$claude_file" "$opencode_file" 2>&1); then
-                # Files are same (shouldn't happen if hashes differ, but handle it)
-                echo "$diff_output" | head -20
-            else
-                local diff_exit=$?
-                if [[ "$diff_output" == *"diff:"* && "$diff_output" == *"No such file"* ]]; then
-                    log_error "diff failed: $diff_output"
-                else
-                    # Normal diff output (exit 1 means files differ)
-                    echo "$diff_output" | head -20
-                fi
-            fi
-            echo "  ---"
-            echo ""
-        else
-            match_count=$((match_count + 1))
-        fi
-    done < <(find "$CLAUDE_DIR" -name "*.md" -type f -print0 2>/dev/null | sort -z)
+    local claude_count
+    local opencode_count
+    local mirror_count
+    claude_count=$(count_commands "$CLAUDE_AGENT_DIR")
+    opencode_count=$(count_commands "$OPENCODE_AGENT_DIR")
+    mirror_count=$(count_commands "$AETHER_AGENT_MIRROR_DIR")
 
-    # Report results
-    if [[ "$error_count" -gt 0 ]]; then
-        echo ""
-        log_error "Hash errors in $error_count file(s):"
-        echo -e "$error_files"
+    echo "Claude agents:        $claude_count"
+    echo "OpenCode agents:      $opencode_count"
+    echo "Aether mirror agents: $mirror_count"
+
+    if [[ "$claude_count" != "$opencode_count" ]]; then
+        log_error "Claude/OpenCode agent counts don't match!"
+        return 1
+    fi
+
+    if [[ "$claude_count" != "$mirror_count" ]]; then
+        log_error "Claude/.aether mirror agent counts don't match!"
+        return 1
     fi
 
-    if [[ "$drift_count" -gt 0 ]]; then
+    local claude_files
+    local opencode_files
+    local mirror_files
+    claude_files=$(list_agents "$CLAUDE_AGENT_DIR")
+    opencode_files=$(list_agents "$OPENCODE_AGENT_DIR")
+    mirror_files=$(list_agents "$AETHER_AGENT_MIRROR_DIR")
+
+    if [[ "$claude_files" != "$opencode_files" ]]; then
+        log_error "Claude/OpenCode agent file names don't match!"
         echo ""
-        log_warn "Content drift detected in $drift_count file(s) (non-blocking):"
-        echo -e "$drift_files"
-        # Content drift is advisory — structural sync is what matters
+        echo "Only in Claude:"
+        comm -23 <(echo "$claude_files") <(echo "$opencode_files") | sed 's/^/  /'
+        echo ""
+        echo "Only in OpenCode:"
+        comm -13 <(echo "$claude_files") <(echo "$opencode_files") | sed 's/^/  /'
+        return 1
     fi
 
-    if [[ "$error_count" -gt 0 ]]; then
+    if [[ "$claude_files" != "$mirror_files" ]]; then
+        log_error "Claude/.aether mirror agent file names don't match!"
+        echo ""
+        echo "Only in Claude:"
+        comm -23 <(echo "$claude_files") <(echo "$mirror_files") | sed 's/^/  /'
+        echo ""
+        echo "Only in .aether mirror:"
+        comm -13 <(echo "$claude_files") <(echo "$mirror_files") | sed 's/^/  /'
         return 1
     fi
 
-    log_info "All file contents match (checksums verified: $match_count files)"
+    # Claude and mirror should be byte-identical.
+    local file
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        local claude_file="$CLAUDE_AGENT_DIR/$file"
+        local mirror_file="$AETHER_AGENT_MIRROR_DIR/$file"
+        local claude_hash
+        local mirror_hash
+        claude_hash=$(compute_hash "$claude_file")
+        mirror_hash=$(compute_hash "$mirror_file")
+        if [[ "$claude_hash" != "$mirror_hash" ]]; then
+            log_error "Claude/.aether mirror content drift: $file"
+            return 1
+        fi
+    done <<< "$claude_files"
+
+    log_info "Agents are in sync (Claude/OpenCode structural parity, Claude/.aether mirror exact parity)"
     return 0
 }
 
@@ -229,6 +254,13 @@ check_content() {
 show_diff() {
     log_info "Comparing command sets..."
 
+    local yaml_dir="$PROJECT_DIR/.aether/commands"
+    local yaml_count=0
+    if [[ -d "$yaml_dir" ]]; then
+        yaml_count=$(find "$yaml_dir" -name "*.yaml" | wc -l | tr -d ' ')
+    fi
+    echo "YAML source files: $yaml_count"
+
     # Use null delimiter for safe iteration (handles filenames with spaces)
     while IFS= read -r -d '' claude_file; do
         local file
@@ -252,21 +284,26 @@ show_diff() {
 
 # Display help
 show_help() {
-    echo "Aether Command Sync Tool"
+    echo "Aether YAML Generation Validation Tool"
     echo ""
     echo "Usage: $0 [command]"
     echo ""
     echo "Commands:"
-    echo "  check   Check if commands are in sync"
+    echo "  check   Validate generated .md files match YAML sources"
     echo "  diff    Show differences between command sets"
     echo "  help    Show this help message"
     echo ""
     echo "Directories:"
-    echo "  Claude Code: $CLAUDE_DIR"
-    echo "  OpenCode:    $OPENCODE_DIR"
+    echo "  YAML sources:    $PROJECT_DIR/.aether/commands"
+    echo "  Claude output:   $CLAUDE_DIR"
+    echo "  OpenCode output: $OPENCODE_DIR"
+    echo "  Claude agents:   $CLAUDE_AGENT_DIR"
+    echo "  OpenCode agents: $OPENCODE_AGENT_DIR"
+    echo "  Aether mirror:   $AETHER_AGENT_MIRROR_DIR"
     echo ""
-    echo "Note: Commands are maintained manually in both directories."
-    echo "Use this tool to verify they stay in sync."
+    echo "Note: Command specs are maintained in .aether/commands/*.yaml."
+    echo "Run 'npm run generate' to regenerate .md files from YAML sources."
+    echo "Use this tool to verify generated files are up to date."
 }
 
 # Main
@@ -274,8 +311,10 @@ case "${1:-check}" in
     check)
         # Pass 1: file count + name check
         check_sync
-        # Pass 2: content-level checksum comparison
-        check_content
+        # Pass 2: YAML generation check
+        check_yaml_generation
+        # Pass 3: agent sync policy checks
+        check_agent_sync
         ;;
     diff)
         show_diff

package/bin/lib/spawn-logger.js

@@ -10,7 +10,6 @@
 const fs = require('fs');
 const path = require('path');
 const { logActivity } = require('./logger');
-const { recordSpawnTelemetry } = require('./telemetry');
 
 /**
  * Caste emoji mapping for display
@@ -72,20 +71,6 @@ async function logSpawn(repoPath, { parent, caste, child, task, model, status =
     const description = `${child} (${caste}): ${task} [model: ${model || 'default'}]`;
     logActivity('SPAWN', casteForLog, description);
 
-    // Record telemetry for performance tracking
-    // Handle errors gracefully - don't fail spawn logging if telemetry fails
-    try {
-      recordSpawnTelemetry(repoPath, {
-        task: task || 'unknown',
-        caste: caste || 'unknown',
-        model: model || 'default',
-        source: source || 'caste-default',
-        timestamp
-      });
-    } catch (telemetryError) {
-      // Silent fail for telemetry errors
-    }
-
     return true;
   } catch (error) {
     // Silent fail - don't cascade errors from logging