agileflow 2.44.0 → 2.45.0

package/scripts/compress-status.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+
+# compress-status.sh
+# Removes verbose fields from status.json to reduce file size
+# Keeps only essential tracking metadata
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default paths (relative to project root)
+DOCS_DIR="docs"
+STATUS_FILE="$DOCS_DIR/09-agents/status.json"
+
+# Find project root (directory containing .agileflow)
+PROJECT_ROOT="$(pwd)"
+while [[ ! -d "$PROJECT_ROOT/.agileflow" ]] && [[ "$PROJECT_ROOT" != "/" ]]; do
+  PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+done
+
+if [[ "$PROJECT_ROOT" == "/" ]]; then
+  echo -e "${RED}Error: Not in an AgileFlow project (no .agileflow directory found)${NC}"
+  exit 1
+fi
+
+# Update paths to absolute
+STATUS_FILE="$PROJECT_ROOT/$STATUS_FILE"
+
+# Check if status.json exists
+if [[ ! -f "$STATUS_FILE" ]]; then
+  echo -e "${YELLOW}No status.json found at $STATUS_FILE${NC}"
+  exit 0
+fi
+
+echo -e "${BLUE}Compressing status.json...${NC}"
+
+# Get original size
+ORIGINAL_SIZE=$(wc -c < "$STATUS_FILE")
+
+# Compress using Node.js
+if command -v node &> /dev/null; then
+  STATUS_FILE="$STATUS_FILE" node <<'EOF'
+const fs = require('fs');
+
+const statusFile = process.env.STATUS_FILE;
+
+// Read status.json
+const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+const stories = status.stories || {};
+
+// Fields to keep (essential tracking metadata only)
+const KEEP_FIELDS = [
+  'id',
+  'title',
+  'status',
+  'owner',
+  'created_at',
+  'updated_at',
+  'completed_at',
+  'epic',
+  'dependencies',
+  'blocked_by',
+  'blocks',
+  'pr_url',
+  'test_status',
+  'priority',
+  'tags'
+];
+
+// Compress each story
+let removedFields = 0;
+const compressed = {};
+
+for (const [storyId, story] of Object.entries(stories)) {
+  compressed[storyId] = {};
+
+  for (const field of KEEP_FIELDS) {
+    if (story[field] !== undefined) {
+      compressed[storyId][field] = story[field];
+    }
+  }
+
+  const originalFieldCount = Object.keys(story).length;
+  const compressedFieldCount = Object.keys(compressed[storyId]).length;
+  removedFields += (originalFieldCount - compressedFieldCount);
+}
+
+// Update status.json
+status.stories = compressed;
+status.updated = new Date().toISOString();
+fs.writeFileSync(statusFile, JSON.stringify(status, null, 2));
+
+console.log(`\x1b[32m✓ Removed ${removedFields} verbose fields\x1b[0m`);
+console.log(`\x1b[34mStories processed: ${Object.keys(compressed).length}\x1b[0m`);
+EOF
+
+  # Get new size
+  NEW_SIZE=$(wc -c < "$STATUS_FILE")
+  SAVED=$((ORIGINAL_SIZE - NEW_SIZE))
+  PERCENT=$((SAVED * 100 / ORIGINAL_SIZE))
+
+  echo -e "${GREEN}Compression complete!${NC}"
+  echo -e "${BLUE}Original size: ${ORIGINAL_SIZE} bytes${NC}"
+  echo -e "${BLUE}New size: ${NEW_SIZE} bytes${NC}"
+  echo -e "${BLUE}Saved: ${SAVED} bytes (${PERCENT}%)${NC}"
+else
+  echo -e "${RED}Error: Node.js not found. Cannot compress status.json.${NC}"
+  exit 1
+fi
+
+exit 0

package/scripts/expertise-metrics.sh

@@ -0,0 +1,264 @@
+#!/bin/bash
+#
+# expertise-metrics.sh - Metrics dashboard for Agent Expert system
+#
+# Purpose: Track the health and activity of Agent Expert expertise files
+#
+# Metrics tracked:
+#   1. Total experts count
+#   2. Experts with learnings (self-improved at least once)
+#   3. Average file size (lines)
+#   4. Staleness distribution (how old are the files)
+#   5. Recent activity (updated in last 7 days)
+#
+# Usage:
+#   ./scripts/expertise-metrics.sh           # Show metrics dashboard
+#   ./scripts/expertise-metrics.sh --json    # Output as JSON (for logging)
+#   ./scripts/expertise-metrics.sh --csv     # Output as CSV
+#   ./scripts/expertise-metrics.sh --help    # Show help
+#
+
+set -e
+
+# Configuration
+EXPERTS_DIR="packages/cli/src/core/experts"
+
+# Colors
+BLUE='\033[0;34m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Help message
+show_help() {
+    echo "Usage: $0 [--json | --csv | --help]"
+    echo ""
+    echo "Metrics dashboard for Agent Expert expertise files"
+    echo ""
+    echo "Options:"
+    echo "  --json    Output metrics as JSON"
+    echo "  --csv     Output metrics as CSV"
+    echo "  --help    Show this help message"
+    echo ""
+    echo "Metrics tracked:"
+    echo "  - Total experts count"
+    echo "  - Experts with learnings (self-improved)"
+    echo "  - Average file size (lines)"
+    echo "  - Staleness distribution"
+    echo "  - Recent activity (last 7 days)"
+}
+
+# Extract YAML field
+get_yaml_field() {
+    local file="$1"
+    local field="$2"
+    grep "^${field}:" "$file" 2>/dev/null | sed "s/^${field}:[[:space:]]*//" | tr -d '"' || echo ""
+}
+
+# Check if learnings is empty
+has_learnings() {
+    local file="$1"
+    # Check for non-empty learnings
+    if grep -q "^learnings: \[\]" "$file" 2>/dev/null; then
+        return 1  # Empty
+    fi
+    # Check if there's actual content after learnings:
+    local after_learnings
+    after_learnings=$(sed -n '/^learnings:/,/^[a-z]/p' "$file" | grep -v "^#" | grep -v "^learnings:" | grep -v "^$" | grep "^  -" | head -1)
+    if [ -n "$after_learnings" ]; then
+        return 0  # Has content
+    fi
+    return 1  # Empty
+}
+
+# Get file line count
+get_line_count() {
+    wc -l < "$1" | tr -d ' '
+}
+
+# Calculate days since date
+days_since() {
+    local date_str="$1"
+    local date_epoch now_epoch
+
+    if [[ "$date_str" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]]; then
+        date_epoch=$(date -d "$date_str" +%s 2>/dev/null || date -j -f "%Y-%m-%d" "$date_str" +%s 2>/dev/null)
+    else
+        echo "999"
+        return
+    fi
+
+    now_epoch=$(date +%s)
+    echo $(( (now_epoch - date_epoch) / 86400 ))
+}
+
+# Count learnings entries
+count_learnings() {
+    local file="$1"
+    local count
+    # Count lines starting with "  - date:" in learnings section
+    count=$(grep -c "^  - date:" "$file" 2>/dev/null) || count=0
+    echo "$count"
+}
+
+# Main collection
+collect_metrics() {
+    local script_dir
+    script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    cd "$script_dir/.."
+
+    # Initialize counters
+    local total=0
+    local with_learnings=0
+    local total_lines=0
+    local recent_updates=0
+    local stale_7d=0
+    local stale_30d=0
+    local stale_90d=0
+    local total_learnings=0
+
+    # Collect data
+    local domains=()
+    local details=()
+
+    for dir in "$EXPERTS_DIR"/*/; do
+        local domain
+        domain=$(basename "$dir")
+        [ "$domain" = "templates" ] && continue
+
+        local file="$dir/expertise.yaml"
+        [ ! -f "$file" ] && continue
+
+        total=$((total + 1))
+        domains+=("$domain")
+
+        # File size
+        local lines
+        lines=$(get_line_count "$file")
+        total_lines=$((total_lines + lines))
+
+        # Learnings
+        local learnings_count
+        learnings_count=$(count_learnings "$file")
+        total_learnings=$((total_learnings + learnings_count))
+        if [ "$learnings_count" -gt 0 ]; then
+            with_learnings=$((with_learnings + 1))
+        fi
+
+        # Staleness
+        local last_updated days_old
+        last_updated=$(get_yaml_field "$file" "last_updated")
+        days_old=$(days_since "$last_updated")
+
+        if [ "$days_old" -le 7 ]; then
+            recent_updates=$((recent_updates + 1))
+        elif [ "$days_old" -le 30 ]; then
+            stale_7d=$((stale_7d + 1))
+        elif [ "$days_old" -le 90 ]; then
+            stale_30d=$((stale_30d + 1))
+        else
+            stale_90d=$((stale_90d + 1))
+        fi
+
+        # Store detail
+        details+=("$domain,$lines,$learnings_count,$days_old")
+    done
+
+    # Calculate averages
+    local avg_lines=0
+    if [ "$total" -gt 0 ]; then
+        avg_lines=$((total_lines / total))
+    fi
+
+    # Output based on format
+    local format="${1:-dashboard}"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+    case "$format" in
+        json)
+            echo "{"
+            echo "  \"timestamp\": \"$timestamp\","
+            echo "  \"total_experts\": $total,"
+            echo "  \"with_learnings\": $with_learnings,"
+            echo "  \"self_improve_rate\": $(awk -v w="$with_learnings" -v t="$total" 'BEGIN {printf "%.1f", (w / t) * 100}'),"
+            echo "  \"total_learnings\": $total_learnings,"
+            echo "  \"avg_file_lines\": $avg_lines,"
+            echo "  \"staleness\": {"
+            echo "    \"recent_7d\": $recent_updates,"
+            echo "    \"stale_8_30d\": $stale_7d,"
+            echo "    \"stale_31_90d\": $stale_30d,"
+            echo "    \"stale_90d_plus\": $stale_90d"
+            echo "  }"
+            echo "}"
+            ;;
+        csv)
+            local csv_rate
+            csv_rate=$(awk -v w="$with_learnings" -v t="$total" 'BEGIN {printf "%.1f", (w / t) * 100}')
+            echo "timestamp,total_experts,with_learnings,self_improve_rate,total_learnings,avg_file_lines,recent_7d,stale_8_30d,stale_31_90d,stale_90d_plus"
+            echo "$timestamp,$total,$with_learnings,$csv_rate,$total_learnings,$avg_lines,$recent_updates,$stale_7d,$stale_30d,$stale_90d"
+            ;;
+        dashboard)
+            echo ""
+            echo -e "${BLUE}╔════════════════════════════════════════════════╗${NC}"
+            echo -e "${BLUE}║        Agent Expert Metrics Dashboard          ║${NC}"
+            echo -e "${BLUE}╚════════════════════════════════════════════════╝${NC}"
+            echo ""
+            echo -e "${GREEN}Summary${NC}"
+            echo "─────────────────────────────────────────────────"
+            printf "%-30s %s\n" "Total Experts:" "$total"
+            local pct
+            pct=$(awk -v w="$with_learnings" -v t="$total" 'BEGIN {printf "%.0f", (w / t) * 100}')
+            printf "%-30s %s (%s%%)\n" "With Learnings:" "$with_learnings" "$pct"
+            printf "%-30s %s\n" "Total Learnings Recorded:" "$total_learnings"
+            printf "%-30s %s lines\n" "Avg File Size:" "$avg_lines"
+            echo ""
+            echo -e "${YELLOW}Staleness Distribution${NC}"
+            echo "─────────────────────────────────────────────────"
+            printf "%-30s %s\n" "Updated in last 7 days:" "$recent_updates"
+            printf "%-30s %s\n" "8-30 days old:" "$stale_7d"
+            printf "%-30s %s\n" "31-90 days old:" "$stale_30d"
+            printf "%-30s %s\n" "90+ days old:" "$stale_90d"
+            echo ""
+            echo -e "${BLUE}Self-Improve Health${NC}"
+            echo "─────────────────────────────────────────────────"
+            if [ "$with_learnings" -eq 0 ]; then
+                echo "No agents have self-improved yet"
+                echo "   Run agents and they will update expertise.yaml"
+            elif [ "$with_learnings" -lt $((total / 2)) ]; then
+                local rate
+                rate=$(awk -v w="$with_learnings" -v t="$total" 'BEGIN {printf "%.0f", (w / t) * 100}')
+                echo "$with_learnings/$total agents have started learning"
+                echo "   Self-improve rate: ${rate}%"
+            else
+                local avg
+                avg=$(awk -v l="$total_learnings" -v t="$total" 'BEGIN {printf "%.1f", l / t}')
+                echo "Good adoption: $with_learnings/$total agents learning"
+                echo "   Average learnings per expert: $avg"
+            fi
+            echo ""
+            echo "Generated: $timestamp"
+            ;;
+    esac
+}
+
+# Main
+main() {
+    case "$1" in
+        --help|-h)
+            show_help
+            exit 0
+            ;;
+        --json)
+            collect_metrics "json"
+            ;;
+        --csv)
+            collect_metrics "csv"
+            ;;
+        *)
+            collect_metrics "dashboard"
+            ;;
+    esac
+}
+
+main "$@"

package/scripts/get-env.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * get-env.js - Helper script to output environment information
+ *
+ * This script can be called from hooks or other automation to get
+ * consistent environment information about the AgileFlow project.
+ *
+ * Usage:
+ *   node scripts/get-env.js [--json] [--compact]
+ *
+ * Flags:
+ *   --json     Output as JSON
+ *   --compact  Minimal output for status line
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+function getProjectInfo() {
+  const rootDir = path.resolve(__dirname, '..');
+
+  // Read package.json files
+  let cliPackage = {};
+  let rootPackage = {};
+
+  try {
+    cliPackage = JSON.parse(
+      fs.readFileSync(path.join(rootDir, 'packages/cli/package.json'), 'utf8')
+    );
+  } catch (err) {
+    // Ignore if not found
+  }
+
+  try {
+    rootPackage = JSON.parse(
+      fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8')
+    );
+  } catch (err) {
+    // Ignore if not found
+  }
+
+  // Get git info
+  let gitBranch = 'unknown';
+  let gitCommit = 'unknown';
+  let recentCommits = [];
+
+  try {
+    gitBranch = execSync('git branch --show-current', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+    gitCommit = execSync('git rev-parse --short HEAD', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+
+    // Get recent commits (last 5)
+    const commitLog = execSync('git log --oneline -5 2>/dev/null', {
+      cwd: rootDir,
+      encoding: 'utf8'
+    }).trim();
+    recentCommits = commitLog.split('\n').filter(Boolean);
+  } catch (err) {
+    // Ignore if git not available
+  }
+
+  // Get AgileFlow status info
+  let activeStories = [];
+  let wipCount = 0;
+  let blockedCount = 0;
+  let activeEpics = [];
+
+  try {
+    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+    if (fs.existsSync(statusPath)) {
+      const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+
+      // Get active stories
+      if (status.stories) {
+        Object.entries(status.stories).forEach(([id, story]) => {
+          if (story.status === 'in_progress') {
+            activeStories.push({ id, title: story.title, owner: story.owner });
+            wipCount++;
+          }
+          if (story.status === 'blocked') {
+            blockedCount++;
+          }
+        });
+      }
+
+      // Get active epics
+      if (status.epics) {
+        Object.entries(status.epics).forEach(([id, epic]) => {
+          if (epic.status !== 'complete') {
+            activeEpics.push({ id, title: epic.title });
+          }
+        });
+      }
+    }
+  } catch (err) {
+    // Ignore if status.json not available
+  }
+
+  return {
+    project: {
+      name: cliPackage.name || rootPackage.name || 'AgileFlow',
+      version: cliPackage.version || rootPackage.version || 'unknown',
+      description: cliPackage.description || rootPackage.description || '',
+      rootDir: rootDir,
+    },
+    git: {
+      branch: gitBranch,
+      commit: gitCommit,
+      recentCommits: recentCommits,
+    },
+    agileflow: {
+      activeStories: activeStories,
+      wipCount: wipCount,
+      blockedCount: blockedCount,
+      activeEpics: activeEpics,
+    },
+    system: {
+      node: process.version,
+      platform: os.platform(),
+      arch: os.arch(),
+      hostname: os.hostname(),
+      user: os.userInfo().username,
+    },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function formatOutput(info, asJson = false, compact = false) {
+  if (asJson) {
+    return JSON.stringify(info, null, 2);
+  }
+
+  if (compact) {
+    // Minimal output for status line
+    const story = info.agileflow.activeStories[0];
+    const storyStr = story ? `${story.id}: ${story.title.substring(0, 30)}` : 'No active story';
+    return `[${info.git.branch}] ${storyStr} | WIP: ${info.agileflow.wipCount}`;
+  }
+
+  // ANSI colors (including brand color #e8683a as RGB)
+  const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    red: '\x1b[31m',
+    brand: '\x1b[38;2;232;104;58m', // #e8683a - AgileFlow brand orange
+  };
+
+  // Beautiful compact colorful format
+  const lines = [];
+
+  // Header line with project info (brand color name, dim version, colored branch)
+  const branchColor = info.git.branch === 'main' ? c.green : c.cyan;
+  lines.push(`${c.brand}${c.bold}${info.project.name}${c.reset} ${c.dim}v${info.project.version}${c.reset} | ${branchColor}${info.git.branch}${c.reset} ${c.dim}(${info.git.commit})${c.reset}`);
+
+  // Status line (yellow WIP, red blocked)
+  const wipColor = info.agileflow.wipCount > 0 ? c.yellow : c.dim;
+  let statusLine = info.agileflow.wipCount > 0
+    ? `${wipColor}WIP: ${info.agileflow.wipCount}${c.reset}`
+    : `${c.dim}No active work${c.reset}`;
+  if (info.agileflow.blockedCount > 0) {
+    statusLine += ` | ${c.red}Blocked: ${info.agileflow.blockedCount}${c.reset}`;
+  }
+  lines.push(statusLine);
+
+  // Active story (if any) - just the first one (blue label)
+  if (info.agileflow.activeStories.length > 0) {
+    const story = info.agileflow.activeStories[0];
+    lines.push(`${c.blue}Current:${c.reset} ${story.id} - ${story.title}`);
+  }
+
+  // Last commit (just one, dim)
+  if (info.git.recentCommits.length > 0) {
+    lines.push(`${c.dim}Last: ${info.git.recentCommits[0]}${c.reset}`);
+  }
+
+  return lines.join('\n');
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const asJson = args.includes('--json');
+  const compact = args.includes('--compact');
+
+  try {
+    const info = getProjectInfo();
+    console.log(formatOutput(info, asJson, compact));
+    process.exit(0);
+  } catch (err) {
+    console.error('Error getting environment info:', err.message);
+    process.exit(1);
+  }
+}
+
+// Export for use as module
+module.exports = { getProjectInfo, formatOutput };