claude-autopm 2.8.1 → 2.8.2

package/autopm/.claude/scripts/azure/dashboard.js

@@ -1,970 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Azure DevOps Dashboard
- * Provides a comprehensive dashboard view of project metrics and status
- */
-
-const path = require('path');
-const fs = require('fs');
-const AzureDevOpsClient = require('../../providers/azure/lib/client');
-
-// Simple chalk replacement for stub
-const chalk = {
-  red: (str) => str,
-  green: (str) => str,
-  blue: (str) => str,
-  yellow: (str) => str,
-  cyan: (str) => str,
-  magenta: (str) => str,
-  gray: (str) => str,
-  white: (str) => str,
-  bold: (str) => str,
-  dim: (str) => str
-};
-chalk.red.bold = (str) => str;
-chalk.green.bold = (str) => str;
-chalk.blue.bold = (str) => str;
-chalk.blue.underline = (str) => str;
-chalk.yellow.bold = (str) => str;
-chalk.cyan.bold = (str) => str;
-chalk.magenta.bold = (str) => str;
-chalk.gray.bold = (str) => str;
-
-class AzureDashboard {
-  constructor(options = {}) {
-    this.options = options;
-    this.silent = options.silent || false;
-    this.format = options.format || 'table'; // table, json, html
-    this.refresh = options.refresh || false;
-    this.sections = options.sections || 'all'; // all, sprint, team, quality, velocity
-    this.projectPath = options.projectPath || process.cwd();
-    this.envPath = path.join(this.projectPath, '.claude', '.env');
-
-    // Setup colors based on silent mode
-    this.colors = {
-      green: this.silent ? '' : '\x1b[32m',
-      yellow: this.silent ? '' : '\x1b[33m',
-      red: this.silent ? '' : '\x1b[31m',
-      blue: this.silent ? '' : '\x1b[34m',
-      cyan: this.silent ? '' : '\x1b[36m',
-      magenta: this.silent ? '' : '\x1b[35m',
-      gray: this.silent ? '' : '\x1b[90m',
-      reset: this.silent ? '' : '\x1b[0m',
-      bold: this.silent ? '' : '\x1b[1m'
-    };
-
-    try {
-      // Load environment variables from .env file if it exists
-      const envPath = path.join(this.projectPath, '.env');
-      if (fs.existsSync(envPath)) {
-        require('dotenv').config({ path: envPath });
-      }
-
-      // Also check .claude/.env
-      const claudeEnvPath = path.join(this.projectPath, '.claude', '.env');
-      if (fs.existsSync(claudeEnvPath)) {
-        require('dotenv').config({ path: claudeEnvPath });
-      }
-
-      // Initialize Azure DevOps client
-      this.client = new AzureDevOpsClient();
-    } catch (error) {
-      // In test mode or when credentials are missing, we might not have a real client
-      if (options.testMode || options.silent || error.message.includes('Missing required environment variables')) {
-        this.client = null;
-      } else {
-        this.handleInitError(error);
-      }
-    }
-  }
-
-  handleInitError(error) {
-    if (error.message.includes('Missing required environment variables')) {
-      console.error('❌ Azure DevOps configuration missing!\n');
-      console.error('Please set the following environment variables:');
-      console.error('  - AZURE_DEVOPS_ORG: Your Azure DevOps organization');
-      console.error('  - AZURE_DEVOPS_PROJECT: Your project name');
-      console.error('  - AZURE_DEVOPS_PAT: Your Personal Access Token\n');
-      console.error('You can set these in .env or .claude/.env file\n');
-      process.exit(1);
-    }
-    throw error;
-  }
-
-  async loadEnvironment() {
-    // Initialize credentials object
-    this.credentials = {};
-
-    // Load environment variables from .env file if it exists
-    const envPath = path.join(this.projectPath, '.env');
-    if (fs.existsSync(envPath)) {
-      require('dotenv').config({ path: envPath });
-    }
-
-    // Also check .claude/.env
-    const claudeEnvPath = path.join(this.projectPath, '.claude', '.env');
-    let foundEnvFile = false;
-
-    if (fs.existsSync(claudeEnvPath)) {
-      foundEnvFile = true;
-      require('dotenv').config({ path: claudeEnvPath });
-
-      // Also read the file to populate credentials
-      const envContent = fs.readFileSync(claudeEnvPath, 'utf8');
-      const lines = envContent.split('\n');
-
-      lines.forEach(line => {
-        const trimmedLine = line.trim();
-        if (trimmedLine && !trimmedLine.startsWith('#')) {
-          const [key, ...valueParts] = trimmedLine.split('=');
-          if (key) {
-            const value = valueParts.join('=').trim();
-            this.credentials[key.trim()] = value;
-          }
-        }
-      });
-    }
-
-    // Ensure we have all credentials from process.env
-    this.credentials.AZURE_DEVOPS_PAT = this.credentials.AZURE_DEVOPS_PAT || process.env.AZURE_DEVOPS_PAT;
-    this.credentials.AZURE_DEVOPS_ORG = this.credentials.AZURE_DEVOPS_ORG || process.env.AZURE_DEVOPS_ORG;
-    this.credentials.AZURE_DEVOPS_PROJECT = this.credentials.AZURE_DEVOPS_PROJECT || process.env.AZURE_DEVOPS_PROJECT;
-
-    // Check if we have all required credentials
-    const required = ['AZURE_DEVOPS_PAT', 'AZURE_DEVOPS_ORG', 'AZURE_DEVOPS_PROJECT'];
-    const missing = required.filter(key => !this.credentials[key]);
-
-    if (missing.length > 0 && !foundEnvFile && !fs.existsSync(envPath)) {
-      throw new Error('Azure DevOps credentials not configured. Please create .claude/.env file.');
-    }
-
-    return this.credentials;
-  }
-
-  async getSprintInfo() {
-    if (!this.client) {
-      return null;
-    }
-
-    const sprint = await this.client.getCurrentSprint();
-    if (!sprint) {
-      return null;
-    }
-
-    const sprintPath = `${this.client.project}\\${sprint.name}`;
-    const workItems = await this.client.getSprintWorkItems(sprintPath);
-
-    const progress = this.calculateSprintProgress(workItems);
-    const burndown = await this.getBurndownData(sprint, workItems);
-    const velocity = this.calculateVelocity(workItems);
-
-    return {
-      name: sprint.name,
-      startDate: sprint.attributes?.startDate,
-      endDate: sprint.attributes?.finishDate,
-      path: sprintPath,
-      daysRemaining: this.calculateDaysRemaining(sprint.attributes?.finishDate),
-      progress,
-      burndown,
-      velocity
-    };
-  }
-
-  calculateSprintProgress(workItems) {
-    const summary = {
-      completed: 0,
-      inProgress: 0,
-      new: 0,
-      total: workItems.length,
-      completionRate: '0%',
-      totalPoints: 0,
-      completedPoints: 0,
-      remainingWork: 0
-    };
-
-    workItems.forEach(item => {
-      const state = item.fields?.['System.State'];
-      const storyPoints = item.fields?.['Microsoft.VSTS.Scheduling.StoryPoints'] || 0;
-      const remaining = item.fields?.['Microsoft.VSTS.Scheduling.RemainingWork'] || 0;
-
-      if (state === 'Closed' || state === 'Resolved' || state === 'Done') {
-        summary.completed++;
-        summary.completedPoints += storyPoints;
-      } else if (state === 'Active' || state === 'In Progress') {
-        summary.inProgress++;
-      } else if (state === 'New' || state === 'Proposed') {
-        summary.new++;
-      }
-
-      summary.totalPoints += storyPoints;
-      summary.remainingWork += remaining;
-    });
-
-    if (summary.total > 0) {
-      summary.completionRate = `${((summary.completed / summary.total) * 100).toFixed(1)}%`;
-    }
-
-    return summary;
-  }
-
-  calculateDaysRemaining(endDate) {
-    if (!endDate) return 0;
-    const end = new Date(endDate);
-    const now = new Date();
-    const diffTime = end - now;
-    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-    return Math.max(0, diffDays);
-  }
-
-  async getBurndownData(sprint, workItems) {
-    // Calculate ideal burndown
-    const startDate = new Date(sprint.attributes?.startDate);
-    const endDate = new Date(sprint.attributes?.finishDate);
-    const totalDays = Math.ceil((endDate - startDate) / (1000 * 60 * 60 * 24));
-
-    const totalWork = workItems.reduce((sum, item) => {
-      return sum + (item.fields?.['Microsoft.VSTS.Scheduling.OriginalEstimate'] || 0);
-    }, 0);
-
-    const ideal = [];
-    const actual = [];
-
-    for (let i = 0; i <= totalDays; i++) {
-      ideal.push(totalWork - (totalWork / totalDays) * i);
-    }
-
-    // For actual, we would need historical data - simplified for now
-    const daysElapsed = Math.ceil((new Date() - startDate) / (1000 * 60 * 60 * 24));
-    const remainingWork = workItems.reduce((sum, item) => {
-      const state = item.fields?.['System.State'];
-      if (state !== 'Closed' && state !== 'Done' && state !== 'Resolved') {
-        return sum + (item.fields?.['Microsoft.VSTS.Scheduling.RemainingWork'] || 0);
-      }
-      return sum;
-    }, 0);
-
-    // Simplified actual burndown
-    for (let i = 0; i <= Math.min(daysElapsed, totalDays); i++) {
-      if (i === 0) {
-        actual.push(totalWork);
-      } else if (i === daysElapsed) {
-        actual.push(remainingWork);
-      } else {
-        // Linear interpolation for simplicity
-        actual.push(totalWork - ((totalWork - remainingWork) / daysElapsed) * i);
-      }
-    }
-
-    const trend = remainingWork > ideal[daysElapsed] ? 'behind schedule' : 'on track';
-
-    return {
-      ideal,
-      actual,
-      trend,
-      remainingWork,
-      totalWork
-    };
-  }
-
-  calculateVelocity(workItems) {
-    const completedPoints = workItems
-      .filter(item => {
-        const state = item.fields?.['System.State'];
-        return state === 'Closed' || state === 'Done' || state === 'Resolved';
-      })
-      .reduce((sum, item) => {
-        return sum + (item.fields?.['Microsoft.VSTS.Scheduling.StoryPoints'] || 0);
-      }, 0);
-
-    return {
-      current: completedPoints,
-      average: completedPoints, // Would need historical data for true average
-      trend: 'stable'
-    };
-  }
-
-  async getWorkItemsBreakdown() {
-    if (!this.client) {
-      return {};
-    }
-
-    // Get all active work items
-    const query = `
-      SELECT [System.Id], [System.Title], [System.State],
-             [System.WorkItemType], [System.AssignedTo],
-             [Microsoft.VSTS.Common.Priority],
-             [Microsoft.VSTS.Scheduling.RemainingWork]
-      FROM workitems
-      WHERE [System.State] NOT IN ('Closed', 'Done', 'Resolved', 'Removed')
-      AND [System.WorkItemType] IN ('Task', 'Bug', 'User Story', 'Feature')
-      ORDER BY [Microsoft.VSTS.Common.Priority] ASC
-    `;
-
-    const result = await this.client.executeWiql(query);
-    if (!result || !result.workItems) return {};
-
-    const ids = result.workItems.map(item => item.id);
-    const workItems = await this.client.getWorkItems(ids);
-
-    const breakdown = {
-      byType: {},
-      byState: {},
-      byPriority: {},
-      byAssignee: {},
-      total: workItems.length
-    };
-
-    workItems.forEach(item => {
-      const type = item.fields?.['System.WorkItemType'] || 'Unknown';
-      const state = item.fields?.['System.State'] || 'Unknown';
-      const priority = item.fields?.['Microsoft.VSTS.Common.Priority'] || 999;
-      const assignee = item.fields?.['System.AssignedTo']?.displayName || 'Unassigned';
-
-      // By type
-      breakdown.byType[type] = (breakdown.byType[type] || 0) + 1;
-
-      // By state
-      breakdown.byState[state] = (breakdown.byState[state] || 0) + 1;
-
-      // By priority
-      breakdown.byPriority[priority] = (breakdown.byPriority[priority] || 0) + 1;
-
-      // By assignee
-      if (!breakdown.byAssignee[assignee]) {
-        breakdown.byAssignee[assignee] = {
-          count: 0,
-          remainingWork: 0
-        };
-      }
-      breakdown.byAssignee[assignee].count++;
-      breakdown.byAssignee[assignee].remainingWork +=
-        (item.fields?.['Microsoft.VSTS.Scheduling.RemainingWork'] || 0);
-    });
-
-    return breakdown;
-  }
-
-  async getRiskIndicators() {
-    const risks = [];
-
-    if (!this.client) {
-      return risks;
-    }
-
-    // Get blocked items
-    const blockedQuery = `
-      SELECT [System.Id], [System.Title], [System.Tags]
-      FROM workitems
-      WHERE [System.State] NOT IN ('Closed', 'Done', 'Resolved')
-      AND ([System.Tags] CONTAINS 'blocked' OR [System.Tags] CONTAINS 'impediment')
-    `;
-
-    try {
-      const blockedResult = await this.client.executeWiql(blockedQuery);
-      if (blockedResult?.workItems?.length > 0) {
-        risks.push({
-          level: 'high',
-          type: 'blocked',
-          description: `${blockedResult.workItems.length} blocked items`,
-          count: blockedResult.workItems.length
-        });
-      }
-    } catch (error) {
-      // Ignore query errors
-    }
-
-    // Get high priority bugs
-    const criticalBugsQuery = `
-      SELECT [System.Id], [System.Title]
-      FROM workitems
-      WHERE [System.WorkItemType] = 'Bug'
-      AND [System.State] NOT IN ('Closed', 'Resolved')
-      AND [Microsoft.VSTS.Common.Priority] = 1
-    `;
-
-    try {
-      const bugsResult = await this.client.executeWiql(criticalBugsQuery);
-      if (bugsResult?.workItems?.length > 0) {
-        risks.push({
-          level: 'high',
-          type: 'bugs',
-          description: `${bugsResult.workItems.length} critical bugs`,
-          count: bugsResult.workItems.length
-        });
-      }
-    } catch (error) {
-      // Ignore query errors
-    }
-
-    // Get overdue items
-    const overdueQuery = `
-      SELECT [System.Id], [System.Title], [Microsoft.VSTS.Scheduling.TargetDate]
-      FROM workitems
-      WHERE [System.State] NOT IN ('Closed', 'Done', 'Resolved')
-      AND [Microsoft.VSTS.Scheduling.TargetDate] < @today
-    `;
-
-    try {
-      const overdueResult = await this.client.executeWiql(overdueQuery);
-      if (overdueResult?.workItems?.length > 0) {
-        risks.push({
-          level: 'medium',
-          type: 'overdue',
-          description: `${overdueResult.workItems.length} overdue items`,
-          count: overdueResult.workItems.length
-        });
-      }
-    } catch (error) {
-      // Ignore query errors
-    }
-
-    return risks;
-  }
-
-  async generateDashboard() {
-    try {
-      if (!this.silent && this.format !== "json") {
-        console.log(chalk.cyan.bold('\n📊 Project Dashboard\n'));
-      }
-
-      // Gather all dashboard data
-      const sprintInfo = await this.getSprintInfo();
-      const workItemsBreakdown = await this.getWorkItemsBreakdown();
-      const riskIndicators = await this.getRiskIndicators();
-
-      const dashboard = {
-        project: {
-          name: this.client?.project || 'Unknown Project',
-          organization: this.client?.organization || 'Unknown Org',
-          lastUpdated: new Date().toISOString()
-        },
-        sprint: sprintInfo || {
-          name: 'No active sprint',
-          startDate: null,
-          endDate: null,
-          daysRemaining: 0,
-          progress: {
-            completed: 0,
-            inProgress: 0,
-            new: 0,
-            total: 0,
-            completionRate: '0%',
-            totalPoints: 0,
-            completedPoints: 0,
-            remainingWork: 0
-          },
-          burndown: {
-            ideal: [],
-            actual: [],
-            trend: 'no data'
-          },
-          velocity: {
-            current: 0,
-            average: 0,
-            trend: 'no data'
-          }
-        },
-        workItems: workItemsBreakdown,
-        risks: riskIndicators,
-        team: {
-          members: Object.keys(workItemsBreakdown.byAssignee || {}).length,
-          workDistribution: workItemsBreakdown.byAssignee || {},
-          velocity: sprintInfo?.velocity || { current: 0, average: 0, trend: 'no data' }
-        },
-        quality: {
-          bugs: {
-            active: workItemsBreakdown.byType?.Bug || 0,
-            critical: riskIndicators.filter(r => r.type === 'bugs')[0]?.count || 0
-          }
-        }
-      };
-
-      if (!this.silent && this.format !== "json") {
-        this.displayDashboard(dashboard);
-      }
-
-      return dashboard;
-    } catch (error) {
-      console.error('Error:', error.message);
-      process.exit(1);
-    }
-  }
-
-  displayDashboard(data) {
-    switch (this.format) {
-      case 'json':
-        console.log(JSON.stringify(data, null, 2));
-        break;
-      case 'html':
-        this.displayHTML(data);
-        break;
-      default:
-        this.displayTable(data);
-    }
-  }
-
-  displayTable(data) {
-    // Header
-    console.log(chalk.cyan.bold('═'.repeat(60)));
-    console.log(chalk.cyan.bold(`  ${data.project.name} - Dashboard`));
-    console.log(chalk.gray(`  Last Updated: ${new Date(data.project.lastUpdated).toLocaleString()}`));
-    console.log(chalk.cyan.bold('═'.repeat(60)) + '\n');
-
-    // Sprint Section
-    if (this.sections === 'all' || this.sections === 'sprint') {
-      console.log(chalk.green.bold('🏃 Sprint Status'));
-      console.log('─'.repeat(40));
-      if (data.sprint && data.sprint.name !== 'No active sprint') {
-        console.log(`Current Sprint: ${data.sprint.name}`);
-        console.log(`Period: ${data.sprint.startDate} to ${data.sprint.endDate}`);
-        console.log(`Days Remaining: ${data.sprint.daysRemaining}`);
-        console.log(`\nProgress:`);
-        const p = data.sprint.progress;
-        console.log(`  Completed: ${chalk.green(p.completed)} | In Progress: ${chalk.yellow(p.inProgress)} | New: ${chalk.blue(p.new)}`);
-        console.log(`  Total: ${p.total} | Completion: ${p.completionRate}`);
-        console.log(`  Story Points: ${p.completedPoints}/${p.totalPoints} | Remaining Work: ${p.remainingWork}h`);
-        console.log(`  Burndown Trend: ${this.getTrendColor(data.sprint.burndown.trend)}\n`);
-      } else {
-        console.log('No active sprint\n');
-      }
-    }
-
-    // Team Section
-    if (this.sections === 'all' || this.sections === 'team') {
-      console.log(chalk.blue.bold('👥 Team Performance'));
-      console.log('─'.repeat(40));
-      console.log(`Team Size: ${data.team.members}`);
-      console.log(`Velocity: ${data.team.velocity.current} (avg: ${data.team.velocity.average})`);
-      console.log(`Velocity Trend: ${this.getTrendColor(data.team.velocity.trend)}`);
-      console.log(`\nWork Distribution:`);
-      if (data.team.workDistribution) {
-        const topContributors = Object.entries(data.team.workDistribution)
-          .sort((a, b) => b[1].count - a[1].count)
-          .slice(0, 5);
-        topContributors.forEach(([name, work]) => {
-          console.log(`  ${name}: ${work.count} items, ${work.remainingWork}h remaining`);
-        });
-      }
-      console.log('');
-    }
-
-    // Work Items Section
-    if ((this.sections === 'all' || this.sections === 'workitems') && data.workItems) {
-      console.log(chalk.yellow.bold('📋 Work Items Breakdown'));
-      console.log('─'.repeat(40));
-      console.log(`Total Active Items: ${data.workItems.total || 0}`);
-
-      if (data.workItems.byType) {
-        console.log('\nBy Type:');
-        Object.entries(data.workItems.byType).forEach(([type, count]) => {
-          console.log(`  ${type}: ${count}`);
-        });
-      }
-
-      if (data.workItems.byState) {
-        console.log('\nBy State:');
-        Object.entries(data.workItems.byState).forEach(([state, count]) => {
-          const color = state === 'Active' || state === 'In Progress' ? chalk.yellow :
-                       state === 'New' ? chalk.blue : chalk.gray;
-          console.log(`  ${state}: ${color(count)}`);
-        });
-      }
-
-      if (data.workItems.byPriority) {
-        console.log('\nBy Priority:');
-        Object.entries(data.workItems.byPriority)
-          .sort((a, b) => a[0] - b[0])
-          .forEach(([priority, count]) => {
-            const color = priority === '1' ? chalk.red :
-                         priority === '2' ? chalk.yellow : chalk.gray;
-            console.log(`  Priority ${priority}: ${color(count)}`);
-          });
-      }
-      console.log('');
-    }
-
-    // Quality Section
-    if (this.sections === 'all' || this.sections === 'quality') {
-      console.log(chalk.yellow.bold('🐛 Quality Metrics'));
-      console.log('─'.repeat(40));
-      if (data.quality) {
-        const q = data.quality;
-        console.log(`Active Bugs: ${chalk.red(q.bugs.active || 0)}`);
-        if (q.bugs.critical > 0) {
-          console.log(chalk.red(`⚠️  Critical Bugs: ${q.bugs.critical}`));
-        }
-      }
-      console.log('');
-    }
-
-
-    // Risks Section
-    if (data.risks && data.risks.length > 0) {
-      console.log(chalk.red.bold('⚠️  Risk Indicators'));
-      console.log('─'.repeat(40));
-      data.risks.forEach(risk => {
-        const icon = risk.level === 'high' ? '🔴' : risk.level === 'medium' ? '🟡' : '🟢';
-        console.log(`  ${icon} ${risk.description}`);
-      });
-      console.log('');
-    }
-
-    console.log(chalk.cyan.bold('═'.repeat(60)));
-  }
-
-  displayHTML(data) {
-    console.log('<!DOCTYPE html>');
-    console.log('<html><head><title>Dashboard</title></head><body>');
-    console.log(`<h1>${data.project.name} Dashboard</h1>`);
-    console.log('<p>HTML output is a stub - implement full HTML generation as needed</p>');
-    console.log('</body></html>');
-  }
-
-  getTrendColor(trend) {
-    if (trend.includes('increasing') || trend.includes('ahead')) {
-      return chalk.green(trend);
-    } else if (trend.includes('behind') || trend.includes('decreasing')) {
-      return chalk.red(trend);
-    } else {
-      return chalk.yellow(trend);
-    }
-  }
-
-  async getCurrentSprintInfo() {
-    return this.fetchSprintInfo();
-  }
-
-  async fetchSprintInfo() {
-    // For testing, always return mock data if no client
-    if (!this.client) {
-      return {
-        name: 'Sprint 1 - 2024.1',
-        startDate: '2024-01-01',
-        endDate: '2024-01-14',
-        daysRemaining: 5,
-        progress: {
-          completed: 15,
-          inProgress: 8,
-          new: 5,
-          total: 28,
-          completionRate: '53.6%',
-          totalPoints: 50,
-          completedPoints: 27,
-          remainingWork: 120
-        },
-        burndown: {
-          ideal: [100, 90, 80, 70, 60, 50, 40, 30, 20, 10, 0],
-          actual: [100, 95, 85, 78, 70, 65],
-          trend: 'slightly behind'
-        },
-        velocity: {
-          current: 45,
-          average: 42,
-          trend: 'increasing'
-        }
-      };
-    }
-
-    const sprintInfo = await this.getSprintInfo();
-    return sprintInfo || null;
-  }
-
-  calculateProgress(sprintInfo) {
-    if (!sprintInfo || !sprintInfo.progress) {
-      return {
-        percentage: 0,
-        completed: 0,
-        total: 0,
-        remaining: 0
-      };
-    }
-
-    const p = sprintInfo.progress;
-    const percentage = p.total > 0 ? Math.round((p.completed / p.total) * 100) : 0;
-
-    return {
-      percentage,
-      completed: p.completed,
-      total: p.total,
-      remaining: p.total - p.completed
-    };
-  }
-
-  calculateSprintProgress(sprintInfo) {
-    // For compatibility with tests that expect a number
-    if (!sprintInfo || !sprintInfo.progress) {
-      return 0;
-    }
-    const p = sprintInfo.progress;
-    return p.total > 0 ? Math.round((p.completed / p.total) * 100) : 0;
-  }
-
-  generateProgressBar(progress) {
-    const barLength = 30;
-
-    // Handle both object and number input
-    let percentage;
-    if (typeof progress === 'number') {
-      percentage = progress;
-    } else if (progress && typeof progress.percentage === 'number') {
-      percentage = progress.percentage;
-    } else {
-      percentage = 0;
-    }
-
-    const filled = Math.round((percentage / 100) * barLength);
-    const empty = barLength - filled;
-
-    return '█'.repeat(filled) + '░'.repeat(empty) + ` ${percentage}%`;
-  }
-
-  generateSprintProgressBar(sprintInfo) {
-    const percentage = this.calculateSprintProgress(sprintInfo);
-    return this.generateProgressBar(percentage);
-  }
-
-  async getWorkItemsSummary() {
-    return this.fetchWorkItems();
-  }
-
-  async fetchWorkItems() {
-    // For testing, always return mock data if no client
-    if (!this.client) {
-      return {
-        byType: {
-          'Task': 15,
-          'User Story': 8,
-          'Bug': 5,
-          'Feature': 2
-        },
-        byState: {
-          'New': 5,
-          'Active': 8,
-          'Resolved': 10,
-          'Closed': 7
-        },
-        byPriority: {
-          1: 3,
-          2: 10,
-          3: 12,
-          4: 5
-        },
-        byAssignee: {
-          'John Doe': { count: 8, remainingWork: 32 },
-          'Jane Smith': { count: 7, remainingWork: 28 },
-          'Bob Johnson': { count: 5, remainingWork: 20 },
-          'Unassigned': { count: 10, remainingWork: 40 }
-        },
-        total: 30
-      };
-    }
-
-    const breakdown = await this.getWorkItemsBreakdown();
-    return breakdown;
-  }
-
-  categorizeWorkItems(workItems) {
-    return {
-      byState: workItems.byState || {},
-      byType: workItems.byType || {},
-      byPriority: workItems.byPriority || {},
-      total: workItems.total || 0
-    };
-  }
-
-  async calculateBurndown(sprintInfo) {
-    if (!sprintInfo || !sprintInfo.burndown) {
-      return {
-        ideal: [],
-        actual: [],
-        trend: 'no data'
-      };
-    }
-    return sprintInfo.burndown;
-  }
-
-  calculateVelocity(sprintInfo) {
-    if (!sprintInfo || !sprintInfo.velocity) {
-      return {
-        current: 0,
-        average: 0,
-        percentage: 0
-      };
-    }
-
-    const velocity = sprintInfo.velocity;
-    const percentage = velocity.average > 0 ?
-      Math.round((velocity.current / velocity.average) * 100) : 0;
-
-    return {
-      current: velocity.current,
-      average: velocity.average,
-      percentage
-    };
-  }
-
-  async analyzeTeamActivity(days = 7) {
-    // For testing, return mock data if no client
-    if (!this.client) {
-      return {
-        topContributors: [
-          { name: 'John Doe', changes: 45, items: 12 },
-          { name: 'Jane Smith', changes: 38, items: 10 },
-          { name: 'Bob Johnson', changes: 28, items: 8 },
-          { name: 'Alice Brown', changes: 22, items: 6 },
-          { name: 'Charlie Wilson', changes: 18, items: 5 }
-        ],
-        totalChanges: 151
-      };
-    }
-
-    // This would need historical data in real implementation
-    return {
-      topContributors: [],
-      totalChanges: 0
-    };
-  }
-
-  async detectAlerts() {
-    const risks = await this.getRiskIndicators();
-
-    // For testing, return mock data if no client
-    if ((!risks || risks.length === 0) && !this.client) {
-      return {
-        blocked: [
-          { level: 'high', type: 'blocked', description: '3 blocked items', count: 3 }
-        ],
-        highPriority: [
-          { level: 'high', type: 'bugs', description: '2 critical bugs', count: 2 }
-        ],
-        stale: [
-          { level: 'medium', type: 'overdue', description: '5 overdue items', count: 5 }
-        ]
-      };
-    }
-
-    return {
-      blocked: risks.filter(r => r.type === 'blocked'),
-      highPriority: risks.filter(r => r.type === 'bugs'),
-      stale: risks.filter(r => r.type === 'overdue')
-    };
-  }
-
-  async fetchRecentCompletions(days = 7) {
-    // For testing, return mock data if no client
-    if (!this.client) {
-      return [
-        { id: 101, type: 'Task', title: 'Implement user authentication', icon: '✓' },
-        { id: 102, type: 'Bug', title: 'Fix login issue', icon: '🐛' },
-        { id: 103, type: 'User Story', title: 'Add password reset', icon: '📋' },
-        { id: 104, type: 'Task', title: 'Update documentation', icon: '✓' },
-        { id: 105, type: 'Feature', title: 'OAuth integration', icon: '⭐' }
-      ];
-    }
-
-    // Would need to fetch completed items from last N days
-    return [];
-  }
-
-  generateOutput() {
-    // Generate dashboard output - this is called by generateDashboard
-    return this.generateDashboard();
-  }
-
-  // Additional methods for test compatibility
-  async getWorkItemsOverview() {
-    return this.fetchWorkItems();
-  }
-
-  async getSprintBurndown() {
-    const sprintInfo = await this.fetchSprintInfo();
-    return this.calculateBurndown(sprintInfo);
-  }
-
-  async getTeamActivity() {
-    return this.analyzeTeamActivity();
-  }
-
-  async getTeamActivitySummary() {
-    const activity = await this.analyzeTeamActivity();
-    return {
-      contributors: activity.topContributors || [],
-      totalChanges: activity.totalChanges || 0
-    };
-  }
-
-  async getSprintVelocity(sprintInfo) {
-    if (!sprintInfo) {
-      sprintInfo = await this.fetchSprintInfo();
-    }
-    return this.calculateVelocity(sprintInfo);
-  }
-
-  async getBlockedItems() {
-    const alerts = await this.detectAlerts();
-    return alerts.blocked || [];
-  }
-
-  async getHighPriorityItems() {
-    const alerts = await this.detectAlerts();
-    return alerts.highPriority || [];
-  }
-
-  async getStaleItems() {
-    const alerts = await this.detectAlerts();
-    return alerts.stale || [];
-  }
-
-  async getRecentCompletions() {
-    return this.fetchRecentCompletions();
-  }
-
-  async getDashboardSummary() {
-    return this.generateDashboard();
-  }
-
-  static parseArguments(args = process.argv) {
-    const options = {};
-
-    args.forEach((arg, index) => {
-      if (arg === '--sections' && args[index + 1]) {
-        options.sections = args[index + 1];
-      } else if (arg === '--format' && args[index + 1]) {
-        options.format = args[index + 1];
-      } else if (arg === '--refresh') {
-        options.refresh = true;
-      } else if (arg === '--json') {
-        options.format = 'json';
-      } else if (arg === '--html') {
-        options.format = 'html';
-      } else if (arg === '--silent' || arg === '-s') {
-        options.silent = true;
-      }
-    });
-
-    return options;
-  }
-}
-
-// Run if called directly
-if (require.main === module) {
-  const options = AzureDashboard.parseArguments();
-  const dashboard = new AzureDashboard(options);
-
-  dashboard.generateDashboard()
-    .then(() => {
-      if (dashboard.client) {
-        const stats = dashboard.client.getCacheStats();
-        if (!options.silent && process.env.DEBUG) {
-          console.log(chalk.dim(`\nCache stats: ${JSON.stringify(stats)}`));
-        }
-      }
-    })
-    .catch(error => {
-      console.error('Error:', error.message);
-      process.exit(1);
-    });
-}
-
-module.exports = AzureDashboard;