Communitygithub.com

majiayu000/claude-skill-registry

多项目投资组合分析仪表盘。跨项目聚合KPI、跟踪投资组合健康状况、比较绩效,并支持高管决策。

claude-skill-registry 是什么?

Portfolio Dashboard 是一个专为多项目环境设计的投资组合分析技能,适用于Claude Code等AI助手平台。它能够聚合多个建筑项目的关键绩效指标(KPI),如总价值、按时完成百分比、预算执行率、安全率和风险评分,并提供投资组合级别的可视化和报告。该技能通过`PortfolioDashboard`类实现,支持项目添加、性能汇总、项目比较、风险识别、现金流预测和历史快照保存,帮助用户跟踪趋势、比较项目绩效并优化资源配置。其核心功能包括基于进度和成本绩效指数(CPI/SPI)的健康状态分级(绿色、黄色、红色、灰色),以及对超出预算或进度滞后项目的自动预警,从而有效支持高管决策。

兼容平台✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry/tree/HEAD/skills/analysis/portfolio-dashboard

在你喜欢的 AI 中提问

打开一个已预加载此 Agent Skill 的新对话。

文档

投资组合仪表盘

概述

聚合和分析多个建筑项目的数据,以获得投资组合级别的可见性。跟踪KPI、识别趋势、比较项目绩效,并支持战略性资源分配决策。

投资组合分析框架

┌─────────────────────────────────────────────────────────────────┐
│                  投资组合仪表盘                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  项目 A        项目 B        项目 C         项目 D               │
│     ↓             ↓            ↓            ↓                   │
│  ┌─────────────────────────────────────────────┐                │
│  │              数据聚合                        │                │
│  │  成本 | 进度 | 安全 | 质量 | 风险            │                │
│  └─────────────────────────────────────────────┘                │
│                         ↓                                        │
│  ┌─────────────────────────────────────────────┐                │
│  │           投资组合KPI                        │                │
│  │  📊 总价值    📈 按时完成百分比              │                │
│  │  💰 预算执行率   🛡️ 安全率                  │                │
│  │  ⚠️ 风险评分    📋 资源利用率               │                │
│  └─────────────────────────────────────────────┘                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

技术实现

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"       # 正常
    YELLOW = "yellow"     # 有风险
    RED = "red"           # 关键
    GREY = "grey"         # 未开始/暂停

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

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

    # 成本
    budget: float
    actual_cost: float
    forecast_cost: float
    cost_variance: float = 0.0
    cpi: float = 1.0
    spi: float = 1.0

    # 安全
    recordable_incidents: int = 0
    total_hours: float = 0
    trir: float = 0.0

    # 质量
    defects_open: int = 0
    rework_cost: float = 0.0

    # 风险
    risk_score: float = 0.0
    critical_risks: int = 0

    @property
    def health(self) -> HealthStatus:
        """确定整体项目健康状态。"""
        if self.status in [ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED]:
            return HealthStatus.GREY

        # 如果显著超出预算/进度,则为关键状态
        if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
            return HealthStatus.RED

        # 如果中度偏离轨道,则有风险
        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

    # 绩效
    avg_cpi: float
    avg_spi: float
    on_budget_pct: float
    on_schedule_pct: float

    # 安全
    portfolio_trir: float
    total_incidents: int

    # 健康状态分布
    green_count: int
    yellow_count: int
    red_count: int

    # 趋势
    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:
    """多项目投资组合分析。"""

    # 健康阈值
    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] = []  # 历史数据

    def add_project(self, metrics: ProjectMetrics):
        """添加或更新投资组合中的项目。"""
        self.projects[metrics.project_id] = metrics

    def import_projects(self, projects_data: List[Dict]) -> int:
        """从数据批量导入多个项目。"""
        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)
            )

            # 计算派生指标
            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]:
        """获取活跃项目列表。"""
        return [p for p in self.projects.values()
                if p.status == ProjectStatus.ACTIVE]

    def calculate_portfolio_summary(self) -> PortfolioSummary:
        """计算投资组合级别的摘要指标。"""
        active = self.get_active_projects()
        all_projects = list(self.projects.values())

        if not all_projects:
            return None

        # 总计
        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)

        # 绩效平均值(按预算加权)
        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

        # 预算/进度执行率
        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

        # 安全指标
        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

        # 健康状态分布
        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])

        # 趋势(与之前的快照比较,如果有的话)
        cost_trend = "稳定"
        schedule_trend = "稳定"

        if self.snapshots:
            prev = self.snapshots[-1]
            if avg_cpi > prev.get('avg_cpi', 1.0):
                cost_trend = "改善中"
            elif avg_cpi < prev.get('avg_cpi', 1.0):
                cost_trend = "恶化中"

            if avg_spi > prev.get('avg_spi', 1.0):
                schedule_trend = "改善中"
            elif avg_spi < prev.get('avg_spi', 1.0):
                schedule_trend = "恶化中"

        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:
        """按特定指标比较项目。"""
        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"未知指标: {metric}")

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

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

        # 最佳/最差取决于指标(CPI高好,TRIR低好)
        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]:
        """获取需要关注的项目。"""
        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]:
        """获取整个投资组合中的主要风险。"""
        risks = []

        for p in self.get_active_projects():
            if p.risk_score > 0:
                risks.append({
                    "项目": p.project_name,
                    "风险评分": p.risk_score,
                    "关键风险数": p.critical_risks,
                    "CPI": p.cpi,
                    "SPI": p.spi
                })

        return sorted(risks, key=lambda x: -x['风险评分'])[:limit]

    def forecast_cash_needs(self, months: int = 6) -> List[Dict]:
        """预测整个投资组合的现金需求。"""
        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():
                # 基于剩余工作的简单线性预测
                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_date.strftime("%Y-%m"),
                "预计支出": month_spend
            })

        return forecasts

    def save_snapshot(self):
        """保存当前状态以进行趋势分析。"""
        summary = self.calculate_portfolio_summary()
        if summary:
            self.snapshots.append({
                "日期": datetime.now(),
                "平均CPI": summary.avg_cpi,
                "平均SPI": summary.avg_spi,
                "预算执行率": summary.on_budget_pct,
                "进度执行率": summary.on_schedule_pct,
                "总预测成本": summary.total_forecast_cost
            })

    def generate_report(self) -> str:
        """生成投资组合仪表盘报告。"""
        summary = self.calculate_portfolio_summary()

        if not summary:
            return "投资组合中没有项目"

        lines = [
            "# 投资组合仪表盘",
            "",
            f"**投资组合:** {self.portfolio_name}",
            f"**报告日期:** {summary.report_date.strftime('%Y-%m-%d')}",
            "",
            "## 执行摘要",
            "",
            "| 指标 | 值 |",
            "|------|-----|",
            f"| 总项目数 | {summary.total_projects}({summary.active_projects}个活跃) |",
            f"| 总合同价值 | ${summary.total_contract_value:,.0f} |",
            f"| 总预算 | ${summary.total_budget:,.0f} |",
            f"| 截至今日实际成本 | ${summary.total_actual_cost:,.0f} |",
            f"| 完工预测 | ${summary.total_forecast_cost:,.0f} |",
            f"| 平均CPI | {summary.avg_cpi:.2f} |",
            f"| 平均SPI | {summary.avg_spi:.2f} |",
            f"| 预算执行率 | {summary.on_budget_pct:.1f}% |",
            f"| 进度执行率 | {summary.on_schedule_pct:.1f}% |",
            f"| 投资组合TRIR | {summary.portfolio_trir:.2f} |",
            f"| 总事故数 | {summary.total_incidents} |",
            "",
            "## 健康状态分布",
            "",
            f"- **绿色**(正常):{summary.green_count}",
            f"- **黄色**(有风险):{summary.yellow_count}",
            f"- **红色**(关键):{summary.red_count}",
            "",
            f"## 趋势",
            "",
            f"- 成本趋势:{summary.cost_trend}",
            f"- 进度趋势:{summary.schedule_trend}",
            "",
            "## 需要关注的项目",
            "",
        ]

        at_risk = self.get_projects_at_risk()
        if at_risk:
            for p in at_risk:
                lines.append(f"- **{p.project_name}** - 健康状态: {p.health.value}")
        else:
            lines.append("无")

        lines.append("")
        lines.append("## 主要风险")
        lines.append("")

        top_risks = self.get_top_risks()
        if top_risks:
            for r in top_risks:
                lines.append(f"- **{r['项目']}** - 风险评分: {r['风险评分']:.1f}, 关键风险: {r['关键风险数']}")
        else:
            lines.append("无")

        lines.append("")
        lines.append("## 现金流预测(6个月)")
        lines.append("")

        cash = self.forecast_cash_needs()
        if cash:
            for c in cash:
                lines.append(f"- {c['月份']}: ${c['预计支出']:,.0f}")

        lines.append("")
        lines.append("---")
        lines.append(f"*由 Portfolio Dashboard v1.0 生成*")

        return "\n".join(lines)

    def export_to_csv(self, filename: str):
        """将项目数据导出到CSV文件。"""
        import csv

        with open(filename, 'w', newline='') as f:
            writer = csv.writer(f)
            writer.writerow([
                "项目ID", "项目名称", "状态", "合同价值", "完成百分比",
                "预算", "实际成本", "预测成本", "CPI", "SPI",
                "可记录事故数", "总工时", "TRIR", "风险评分"
            ])

            for p in self.projects.values():
                writer.writerow([
                    p.project_id, p.project_name, p.status.value,
                    p.contract_value, p.percent_complete, p.budget,
                    p.actual_cost, p.forecast_cost, p.cpi, p.spi,
                    p.recordable_incidents, p.total_hours, p.trir, p.risk_score
                ])

使用示例

# 初始化投资组合
dashboard = PortfolioDashboard("企业建筑投资组合")

# 导入项目数据
projects_data = [
    {
        "id": "P001",
        "name": "市中心办公楼",
        "status": "active",
        "contract_value": 50000000,
        "percent_complete": 65,
        "planned_start": datetime(2024, 1, 1),
        "planned_end": datetime(2025, 6, 30),
        "forecast_end": datetime(2025, 7, 15),
        "budget": 48000000,
        "actual_cost": 30000000,
        "forecast_cost": 49000000,
        "cpi": 0.94,
        "spi": 0.96,
        "incidents": 2,
        "total_hours": 150000,
        "risk_score": 6.5,
        "critical_risks": 1
    },
    # ... 更多项目
]

count = dashboard.import_projects(projects_data)
print(f"已导入 {count} 个项目")

# 生成报告
report = dashboard.generate_report()
print(report)

# 比较项目
comparison = dashboard.compare_projects("cpi")
print(f"最佳绩效项目: {comparison.best[0]} (CPI: {comparison.best[1]:.2f})")

# 获取风险项目
at_risk = dashboard.get_projects_at_risk()
print(f"风险项目数: {len(at_risk)}")

# 保存快照以进行趋势分析
dashboard.save_snapshot()

配置

环境变量:

  • PORTFOLIO_DASHBOARD_THRESHOLD_CPI_WARNING: CPI预警阈值(默认: 0.95)
  • PORTFOLIO_DASHBOARD_THRESHOLD_CPI_CRITICAL: CPI关键阈值(默认: 0.85)
  • PORTFOLIO_DASHBOARD_THRESHOLD_SPI_WARNING: SPI预警阈值(默认: 0.95)
  • PORTFOLIO_DASHBOARD_THRESHOLD_SPI_CRITICAL: SPI关键阈值(默认: 0.85)
  • PORTFOLIO_DASHBOARD_THRESHOLD_TRIR_WARNING: TRIR预警阈值(默认: 2.0)
  • PORTFOLIO_DASHBOARD_THRESHOLD_RISK_WARNING: 风险评分预警阈值(默认: 7.0)

Individual skills in this repo

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

majiayu000/claude-skill-registry

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".

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

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

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

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

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

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

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

majiayu000/claude-skill-registry

BlockRun works with Claude Code and Google Antigravity.

majiayu000/claude-skill-registry

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

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

majiayu000/claude-skill-registry

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

CRITICAL: Use for MolyKit AI chat toolkit. Triggers on: BotClient, OpenAI, SSE streaming, AI chat, molykit, PlatformSend, spawn(), ThreadToken, cross-platform async, Chat widget, Messages, PromptInput, Avatar, LLM

majiayu000/claude-skill-registry

AI and machine learning workflow covering LLM application development, RAG implementation, agent architecture, ML pipelines, and AI-powered features.

majiayu000/claude-skill-registry

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

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

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

相关技能