Communitygithub.com

Tableau de Bord de Portefeuille

Analyse multi-projets pour la visibilité d'un portefeuille. Agrégation d'indicateurs, suivi de la santé du portefeuille, comparaison des performances et soutien à la prise de décision stratégique.

Qu'est-ce que Tableau de Bord de Portefeuille ?

Cette compétence implémente un tableau de bord analytique complet pour la gestion de portefeuilles de projets. Elle permet d'agréger des données provenant de plusieurs projets de construction afin d'obtenir une vue d'ensemble du portefeuille. Pour les parties prenantes (chefs de projet, sponsors, etc.), l'outil calcule des indicateurs clés de performance (KPI) agrégés tels que le coût total, le budget, le respect du calendrier, la sécurité, et la santé globale du portefeuille. Il fournit également un suivi des tendances, identifie les projets à risque, et génère des rapports détaillés. La compétence repose sur une architecture orientée objet en Python (dataclasses, collections, énumérations). Elle est conçue pour être exécutée dans des environnements d'IA agentive comme Claude Code ou Cursor, mais peut également être intégrée dans n'importe quel pipeline de données projets. L'utilisateur peut importer des données de projets, enregistrer des instantanés pour l'analyse des tendances, comparer des métriques entre projets, et prévoir les besoins de trésorerie sur une période donnée.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry-data/tree/HEAD/analysis/portfolio-dashboard

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Tableau de Bord de Portefeuille ?

Aperçu

Agrégez et analysez les données de plusieurs projets de construction pour une visibilité au niveau du portefeuille. Suivez les KPI, identifiez les tendances, comparez les performances des projets et soutenez l'allocation stratégique des ressources.

Cadre d'Analyse du Portefeuille

┌─────────────────────────────────────────────────────────────────┐
│                  TABLEAU DE BORD DU PORTEFEUILLE                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  PROJET A    PROJET B    PROJET C    PROJET D                   │
│     ↓             ↓            ↓            ↓                   │
│  ┌─────────────────────────────────────────────┐                │
│  │           AGRÉGATION DE DONNÉES              │                │
│  │  Coût | Calendrier | Sécurité | Qualité | Risque            │
│  └─────────────────────────────────────────────┘                │
│                         ↓                                        │
│  ┌─────────────────────────────────────────────┐                │
│  │          KPI DU PORTEFEUILLE                │                │
│  │  📊 Valeur Totale   📈 % dans les Délais    │                │
│  │  💰 % dans le Budget 🛡️ Taux de Sécurité    │                │
│  │  ⚠️ Score de Risque 📋 Utilisation des Ress.│                │
│  └─────────────────────────────────────────────┘                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Implémentation Technique

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics

class ProjectStatus(Enum):
    PLANNING = "planning"
    ACTIVE = "active"
    ON_HOLD = "on_hold"
    COMPLETE = "complete"
    CANCELLED = "cancelled"

class HealthStatus(Enum):
    GREEN = "green"       # Sur la bonne voie
    YELLOW = "yellow"     # À risque
    RED = "red"           # Critique
    GREY = "grey"         # Non démarré/en pause

@dataclass
class ProjectMetrics:
    project_id: str
    project_name: str
    status: ProjectStatus
    contract_value: float
    percent_complete: float

    # Calendrier
    planned_start: datetime
    planned_end: datetime
    actual_start: Optional[datetime]
    forecast_end: datetime
    schedule_variance_days: int = 0

    # Coût
    budget: float
    actual_cost: float
    forecast_cost: float
    cost_variance: float = 0.0
    cpi: float = 1.0
    spi: float = 1.0

    # Sécurité
    recordable_incidents: int = 0
    total_hours: float = 0
    trir: float = 0.0

    # Qualité
    defects_open: int = 0
    rework_cost: float = 0.0

    # Risque
    risk_score: float = 0.0
    critical_risks: int = 0

    @property
    def health(self) -> HealthStatus:
        """Détermine la santé globale du projet."""
        if self.status in [ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED]:
            return HealthStatus.GREY

        # Critique si significativement hors budget/calendrier
        if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
            return HealthStatus.RED

        # À risque si modérément en retard
        if self.cpi < 0.95 or self.spi < 0.95 or self.critical_risks > 0:
            return HealthStatus.YELLOW

        return HealthStatus.GREEN

@dataclass
class PortfolioSummary:
    report_date: datetime
    total_projects: int
    active_projects: int
    total_contract_value: float
    total_budget: float
    total_actual_cost: float
    total_forecast_cost: float

    # Performance
    avg_cpi: float
    avg_spi: float
    on_budget_pct: float
    on_schedule_pct: float

    # Sécurité
    portfolio_trir: float
    total_incidents: int

    # Répartition de la santé
    green_count: int
    yellow_count: int
    red_count: int

    # Tendances
    cost_trend: str
    schedule_trend: str

@dataclass
class ProjectComparison:
    metric: str
    projects: Dict[str, float]
    avg: float
    best: Tuple[str, float]
    worst: Tuple[str, float]

class PortfolioDashboard:
    """Analyse multi-projets du portefeuille."""

    # Seuils de santé
    THRESHOLDS = {
        "cpi_warning": 0.95,
        "cpi_critical": 0.85,
        "spi_warning": 0.95,
        "spi_critical": 0.85,
        "trir_warning": 2.0,
        "risk_score_warning": 7.0
    }

    def __init__(self, portfolio_name: str):
        self.portfolio_name = portfolio_name
        self.projects: Dict[str, ProjectMetrics] = {}
        self.snapshots: List[Dict] = []  # Données historiques

    def add_project(self, metrics: ProjectMetrics):
        """Ajoute ou met à jour un projet dans le portefeuille."""
        self.projects[metrics.project_id] = metrics

    def import_projects(self, projects_data: List[Dict]) -> int:
        """Importe plusieurs projets à partir de données."""
        count = 0
        for p in projects_data:
            metrics = ProjectMetrics(
                project_id=p['id'],
                project_name=p['name'],
                status=ProjectStatus(p.get('status', 'active')),
                contract_value=p['contract_value'],
                percent_complete=p.get('percent_complete', 0),
                planned_start=p['planned_start'],
                planned_end=p['planned_end'],
                actual_start=p.get('actual_start'),
                forecast_end=p.get('forecast_end', p['planned_end']),
                budget=p['budget'],
                actual_cost=p.get('actual_cost', 0),
                forecast_cost=p.get('forecast_cost', p['budget']),
                cpi=p.get('cpi', 1.0),
                spi=p.get('spi', 1.0),
                recordable_incidents=p.get('incidents', 0),
                total_hours=p.get('total_hours', 0),
                risk_score=p.get('risk_score', 0),
                critical_risks=p.get('critical_risks', 0)
            )

            # Calcul des métriques dérivées
            metrics.cost_variance = metrics.budget - metrics.actual_cost
            metrics.schedule_variance_days = (metrics.planned_end - metrics.forecast_end).days

            if metrics.total_hours > 0:
                metrics.trir = (metrics.recordable_incidents * 200000) / metrics.total_hours

            self.add_project(metrics)
            count += 1

        return count

    def get_active_projects(self) -> List[ProjectMetrics]:
        """Récupère la liste des projets actifs."""
        return [p for p in self.projects.values()
                if p.status == ProjectStatus.ACTIVE]

    def calculate_portfolio_summary(self) -> PortfolioSummary:
        """Calcule les métriques récapitulatives du portefeuille."""
        active = self.get_active_projects()
        all_projects = list(self.projects.values())

        if not all_projects:
            return None

        # Totaux
        total_contract = sum(p.contract_value for p in all_projects)
        total_budget = sum(p.budget for p in all_projects)
        total_actual = sum(p.actual_cost for p in all_projects)
        total_forecast = sum(p.forecast_cost for p in all_projects)

        # Moyennes de performance (pondérées par le budget)
        if total_budget > 0:
            avg_cpi = sum(p.cpi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
            avg_spi = sum(p.spi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
        else:
            avg_cpi = avg_spi = 1.0

        # Pourcentages dans le budget/calendrier
        on_budget = len([p for p in active if p.cpi >= 0.95])
        on_schedule = len([p for p in active if p.spi >= 0.95])

        on_budget_pct = (on_budget / len(active) * 100) if active else 100
        on_schedule_pct = (on_schedule / len(active) * 100) if active else 100

        # Métriques de sécurité
        total_incidents = sum(p.recordable_incidents for p in all_projects)
        total_hours = sum(p.total_hours for p in all_projects)
        portfolio_trir = (total_incidents * 200000 / total_hours) if total_hours > 0 else 0

        # Répartition de la santé
        green = len([p for p in active if p.health == HealthStatus.GREEN])
        yellow = len([p for p in active if p.health == HealthStatus.YELLOW])
        red = len([p for p in active if p.health == HealthStatus.RED])

        # Tendances (comparaison avec l'instantané précédent si disponible)
        cost_trend = "stable"
        schedule_trend = "stable"

        if self.snapshots:
            prev = self.snapshots[-1]
            if avg_cpi > prev.get('avg_cpi', 1.0):
                cost_trend = "amélioration"
            elif avg_cpi < prev.get('avg_cpi', 1.0):
                cost_trend = "dégradation"

            if avg_spi > prev.get('avg_spi', 1.0):
                schedule_trend = "amélioration"
            elif avg_spi < prev.get('avg_spi', 1.0):
                schedule_trend = "dégradation"

        return PortfolioSummary(
            report_date=datetime.now(),
            total_projects=len(all_projects),
            active_projects=len(active),
            total_contract_value=total_contract,
            total_budget=total_budget,
            total_actual_cost=total_actual,
            total_forecast_cost=total_forecast,
            avg_cpi=avg_cpi,
            avg_spi=avg_spi,
            on_budget_pct=on_budget_pct,
            on_schedule_pct=on_schedule_pct,
            portfolio_trir=portfolio_trir,
            total_incidents=total_incidents,
            green_count=green,
            yellow_count=yellow,
            red_count=red,
            cost_trend=cost_trend,
            schedule_trend=schedule_trend
        )

    def compare_projects(self, metric: str) -> ProjectComparison:
        """Compare les projets selon une métrique spécifique."""
        active = self.get_active_projects()

        if not active:
            return None

        metric_map = {
            "cpi": lambda p: p.cpi,
            "spi": lambda p: p.spi,
            "percent_complete": lambda p: p.percent_complete,
            "cost_variance": lambda p: p.cost_variance,
            "trir": lambda p: p.trir,
            "risk_score": lambda p: p.risk_score
        }

        if metric not in metric_map:
            raise ValueError(f"Métrique inconnue : {metric}")

        getter = metric_map[metric]
        values = {p.project_name: getter(p) for p in active}

        avg = statistics.mean(values.values())

        # Meilleur/pire dépend de la métrique (CPI élevé bon, TRIR bas bon)
        if metric in ["trir", "risk_score"]:
            best = min(values.items(), key=lambda x: x[1])
            worst = max(values.items(), key=lambda x: x[1])
        else:
            best = max(values.items(), key=lambda x: x[1])
            worst = min(values.items(), key=lambda x: x[1])

        return ProjectComparison(
            metric=metric,
            projects=values,
            avg=avg,
            best=best,
            worst=worst
        )

    def get_projects_at_risk(self) -> List[ProjectMetrics]:
        """Récupère les projets nécessitant une attention."""
        return [p for p in self.get_active_projects()
                if p.health in [HealthStatus.YELLOW, HealthStatus.RED]]

    def get_top_risks(self, limit: int = 10) -> List[Dict]:
        """Récupère les principaux risques dans le portefeuille."""
        risks = []

        for p in self.get_active_projects():
            if p.risk_score > 0:
                risks.append({
                    "project": p.project_name,
                    "risk_score": p.risk_score,
                    "critical_risks": p.critical_risks,
                    "cpi": p.cpi,
                    "spi": p.spi
                })

        return sorted(risks, key=lambda x: -x['risk_score'])[:limit]

    def forecast_cash_needs(self, months: int = 6) -> List[Dict]:
        """Prévoit les besoins de trésorerie dans le portefeuille."""
        forecasts = []

        for month in range(1, months + 1):
            month_date = datetime.now() + timedelta(days=month * 30)

            month_spend = 0
            for p in self.get_active_projects():
                # Projection linéaire simple basée sur le travail restant
                remaining = p.forecast_cost - p.actual_cost
                months_remaining = max(1, (p.forecast_end - datetime.now()).days / 30)
                monthly_burn = remaining / months_remaining
                month_spend += monthly_burn

            forecasts.append({
                "month": month_date.strftime("%Y-%m"),
                "projected_spend": month_spend
            })

        return forecasts

    def save_snapshot(self):
        """Enregistre l'état actuel pour l'analyse des tendances."""
        summary = self.calculate_portfolio_summary()
        if summary:
            self.snapshots.append({
                "date": datetime.now(),
                "avg_cpi": summary.avg_cpi,
                "avg_spi": summary.avg_spi,
                "on_budget_pct": summary.on_budget_pct,
                "on_schedule_pct": summary.on_schedule_pct,
                "total_forecast": summary.total_forecast_cost
            })

    def generate_report(self) -> str:
        """Génère un rapport du tableau de bord du portefeuille."""
        summary = self.calculate_portfolio_summary()

        if not summary:
            return "Aucun projet dans le portefeuille"

        lines = [
            "# Tableau de Bord du Portefeuille",
            "",
            f"**Portefeuille :** {self.portfolio_name}",
            f"**Date du Rapport :** {summary.report_date.strftime('%Y-%m-%d')}",
            "",
            "## Résumé Exécutif",
            "",
            f"| Métrique | Valeur |",
            f"|--------|-------|",
            f"| Total Projets | {summary.total_projects} ({summary.active_projects} actifs) |",
            f"| Valeur Totale des Contrats | ${summary.total_contract_value:,.0f} |",
            f"| Budget Total | ${summary.total_budget:,.0f} |",
            f"| Coût Réel à Ce Jour | ${summary.total_actual_cost:,.0f} |",
            f"| Prévision à l'Achèvement | ${summary.total_forecast_cost:,.0f} |",
            f"| IPC Moyen | {summary.avg_cpi:.2f} |",
            f"| ISP Moyen | {summary.avg_spi:.2f} |",
            "",
            "## Santé du Portefeuille",
            "",
            f"| Indicateur | Valeur |",
            f"|----------|-------|",
            f"| 🟢 Sur la bonne voie | {summary.green_count} |",
            f"| 🟡 À risque | {summary.yellow_count} |",
            f"| 🔴 Critique | {summary.red_count} |",
            f"| % dans le Budget | {summary.on_budget_pct:.1f}% |",
            f"| % dans les Délais | {summary.on_schedule_pct:.1f}% |",
            "",
            "## Tendances",
            "",
            f"| Métrique | Tendance |",
            f"|----------|--------|",
            f"| Performance des Coûts | {summary.cost_trend} |",
            f"| Performance du Calendrier | {summary.schedule_trend} |",
            "",
            "## Sécurité",
            "",
            f"| Métrique | Valeur |",
            f"|----------|-------|",
            f"| TRIR du Portefeuille | {summary.portfolio_trir:.2f} |",
            f"| Total Incidents | {summary.total_incidents} |",
            "",
            "## Projets à Risque",
            ""
        ]

        # Ajouter les détails des projets à risque
        at_risk = self.get_projects_at_risk()
        if at_risk:
            lines.append(f"| Projet | Santé | IPC | ISP | Score de Risque |")
            lines.append(f"|--------|-------|-----|-----|----------------|")
            for p in at_risk:
                health_icon = {
                    HealthStatus.YELLOW: "🟡",
                    HealthStatus.RED: "🔴"
                }.get(p.health, "⚪")
                lines.append(f"| {p.project_name} | {health_icon} {p.health.value} | {p.cpi:.2f} | {p.spi:.2f} | {p.risk_score:.1f} |")
        else:
            lines.append("Aucun projet n'est actuellement à risque.")

        lines.append("")
        lines.append("---")
        lines.append(f"*Rapport généré par le Tableau de Bord du Portefeuille le {summary.report_date.strftime('%Y-%m-%d %H:%M')}*")

        return "\n".join(lines)

Utilisation

# Initialiser le tableau de bord du portefeuille
dashboard = PortfolioDashboard("Construction Mega-Portfolio")

# Importer les données du projet
dashboard.import_projects(project_data)

# Générer un rapport
generated_report = dashboard.generate_report()
print(generated_report)

# Vérifier les tendances
dashboard.save_snapshot()

# Plus tard...
dashboard.import_projects(new_project_data)
summary = dashboard.calculate_portfolio_summary()
print(f"IPC : {summary.avg_cpi}, ISP : {summary.avg_spi}")
print(f"Tendance des coûts : {summary.cost_trend}")

Cette compétence est conçue pour être utilisée dans des environnements d'IA agentive pour fournir des analyses de portefeuille en temps réel. Elle s'intègre parfaitement dans les flux de travail où les données de projet sont disponibles sous forme structurée.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry-data

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry-data

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry-data

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry-data

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry-data

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

majiayu000/claude-skill-registry-data

Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]

majiayu000/claude-skill-registry-data

Conduct market research on competition and customers. Use when the user says "create a market research report about [business idea]".

majiayu000/claude-skill-registry-data

Conduct technical research on technologies and architecture. Use when the user says "create a technical research report on [topic]".

majiayu000/claude-skill-registry-data

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

Skills associés