undefined

def __init__(self):
    self.tasks = []
    self.dependencies = []
    self.critical_path = []

def create_dependency_map(self, tasks):
    """Create visual dependency network"""
    dependency_graph = {
        'nodes': [],
        'edges': [],
        'critical_items': []
    }

    for task in tasks:
        dependency_graph['nodes'].append({
            'id': task.id,
            'name': task.name,
            'duration': task.duration,
            'owner': task.owner,
            'status': task.status
        })

        for blocker in task.blocked_by:
            dependency_graph['edges'].append({
                'from': blocker,
                'to': task.id,
                'type': 'Finish-to-Start',
                'lag': 0  # days between tasks
            })

    return dependency_graph

def analyze_critical_path(self, tasks):
    """Identify longest chain of dependent tasks"""
    paths = self.find_all_paths(tasks)
    critical_path = max(paths, key=len)

    return {
        'critical_items': critical_path,
        'total_duration': sum(t.duration for t in critical_path),
        'slack_available': 0,
        'any_delay_impacts_schedule': True,
        'monitoring_frequency': 'Daily'
    }

def identify_blocking_dependencies(self, tasks):
    """Find tasks that block other work"""
    blocking_tasks = {}

    for task in tasks:
        blocked_count = sum(1 for t in tasks if task.id in t.blocked_by)
        if blocked_count > 0:
            blocking_tasks[task.id] = {
                'task': task.name,
                'blocking_count': blocked_count,
                'blocked_tasks': [t.id for t in tasks if task.id in t.blocked_by],
                'status': task.status,
                'due_date': task.due_date,
                'risk_level': 'High' if blocked_count > 3 else 'Medium'
            }

    return blocking_tasks

def find_circular_dependencies(self, tasks):
    """Detect circular dependency chains"""
    cycles = []

    for task in tasks:
        visited = set()
        if self.has_cycle(task, visited, tasks):
            cycles.append({
                'cycle': visited,
                'severity': 'Critical',
                'action': 'Resolve immediately'
            })

    return cycles

def has_cycle(self, task, visited, tasks):
    visited.add(task.id)

    for blocker_id in task.blocked_by:
        blocker = next(t for t in tasks if t.id == blocker_id)

        if blocker.id in visited:
            return True
        if self.has_cycle(blocker, visited, tasks):
            return True

    visited.remove(task.id)
    return False

undefined

Dependency Tracking Dashboard:

Project: Platform Migration Q1 2025

---

Critical Path (Blocking Progress):

Task: Database Migration
  ID: TASK-101
  Owner: Data Team
  Duration: 20 days
  Status: In Progress (50%)
  Due Date: Feb 28, 2025
  Blocked By: Schema validation (TASK-95) - DUE TODAY
  Blocks: 6 downstream tasks
  Risk Level: HIGH
  Action Items:
    - Daily standup with Data Team
    - Schema validation must complete by EOD
    - Have rollback plan ready

---

Task: API Contract Finalization
  ID: TASK-102
  Owner: Backend Team
  Duration: 10 days
  Status: Pending (Blocked)
  Depends On: Database Migration (TASK-101)
  Blocks: Frontend implementation (TASK-103), Testing (TASK-104)
  Slack Time: 0 days (critical)
  Early Start: Mar 1, 2025
  Action Items:
    - Start draft specifications now
    - Review with Frontend team
    - Have alternative approach ready

---

High-Risk Dependencies:

Dependency: Third-party Integration
  From: Payment Service API (vendor)
  To: Checkout System (TASK-150)
  Type: External/Uncontrollable
  Status: At Risk (Vendor delay reported)
  Mitigation: Mock service implementation, alternative vendor identified
  Escalation Owner: Product Manager

---

By Team Dependencies:

Backend Team:
  - Database migration → API development
  - Schema design → Data layer implementation
  External: Awaiting Payment Gateway API docs

Frontend Team:
  - API contracts → UI implementation
  - Design system → Component development
  Dependency on Backend: API contract specs (scheduled Feb 20)

DevOps Team:
  - Infrastructure provisioning → Testing environment
  - Kubernetes setup → Staging deployment
  External: Cloud provider quota approval

// Handling and resolving dependency issues

class DependencyResolution {
  resolveDependencyConflict(blocker, blocked) {
    return {
      conflict: {
        blocking_task: blocker.name,
        blocked_task: blocked.name,
        reason: 'Circular dependency detected'
      },
      resolution_options: [
        {
          option: 'Parallelize Work',
          description: 'Identify independent portions that can proceed',
          effort: 'Medium',
          timeline: 'Can save 5 days'
        },
        {
          option: 'Remove/Defer Blocker',
          description: 'Defer non-critical requirements',
          effort: 'Low',
          timeline: 'Immediate'
        },
        {
          option: 'Create Interim Deliverable',
          description: 'Deliver partial results to unblock downstream',
          effort: 'High',
          timeline: 'Can save 8 days'
        }
      ]
    };
  }

  breakDependency(dependency) {
    return {
      current_state: dependency,
      break_strategies: [
        {
          strategy: 'Remove unnecessary dependency',
          action: 'Refactor to eliminate requirement',
          risk: 'Low if verified'
        },
        {
          strategy: 'Mock/Stub external dependency',
          action: 'Create temporary implementation',
          risk: 'Medium - ensures compatibility'
        },
        {
          strategy: 'Parallel development',
          action: 'Make assumptions, validate later',
          risk: 'Medium - rework possible'
        },
        {
          strategy: 'Resource addition',
          action: 'Parallelize work streams',
          risk: 'Low but costly'
        }
      ]
    };
  }

  handleBlockedTask(task) {
    return {
      task_id: task.id,
      status: 'Blocked',
      blocker: task.blocked_by[0],
      time_blocked: task.calculateBlockedDuration(),
      actions: [
        'Notify team of blockage',
        'Escalate if critical path',
        'Identify alternative work',
        'Schedule resolution meeting',
        'Track blocker closure date'
      ],
      escalation: {
        immediate: task.is_critical_path,
        owner: task.program_manager,
        frequency: 'Daily standup until resolved'
      }
    };
  }
}

Key Metrics:

Critical Path Health:
  - Items on Critical Path: 12
  - At-Risk Items: 2 (17%)
  - Completed: 4 (33%)
  - On Track: 6 (50%)
  - Behind: 2 (17%)

Dependency Status:
  - Total Dependencies: 28
  - Resolved: 18
  - Active: 8
  - At Risk: 2
  - Circular: 0 (Good!)

Blocking Impact:
  - Tasks Currently Blocked: 3
  - Team Members Idle: 2
  - Blocked Effort (person-hours): 24
  - Estimated Cost of Blockage: $2,400

Escalations:
  - Open: 1 (Database migration dependency)
  - Resolved This Week: 0
  - Average Resolution Time: 2.3 days