version unknown

issue-triage-report

microsoft@microsoft⭐ 4.7k stars· last commit 2d ago· 358 open issues

Generate comprehensive GitHub Feature Area Status reports for the Windows App SDK repository. Use when asked to create triage reports, identify high-priority issues, analyze feature area health, find issues needing attention, or generate status dashboards. Triggers on requests involving issue triage, area status, priority analysis, bug tracking reports, or engineering team focus areas.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

7.1/10
Verified
Oct 11, 2026

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 4.7k on GitHubGitHub ↗

Very popular

🟢ProSkills ScoreAI Verified
7.1/10
📍

Not yet listed on ClawHub or SkillsMP

// README

Windows App SDK (formerly Project Reunion) is a set of libraries, frameworks, components, and tools that you can use in your apps to access powerful Windows platform functionality from all kinds of apps on many versions of Windows. The Windows App SDK combines the powers of Win32 native applications alongside modern API usage techniques, so your apps light up everywhere your users are.

  • WinUI 3 support: WinUI embodies Fluent Design to enable intuitive, accessible, and powerful experiences and the latest user interface patterns.
  • Access modern features: Modern resource tooling, modern lifecycle helpers, startup tasks, and more without having to rewrite your app.
  • Backwards compatibility: Down to Windows 10 1809 (build 17763). There may be some API that are dependent on new OS features (like new Action Center functionality), however we will do our best to ensure this is the exception and not the norm, and provide reasonable fallbacks when possible.
  • Wide platform support: Win32, WPF, WinForms, and more.
  • Use your current installer: no requirement to use MSIX, but there are reliability/security benefits to using MSIX.

📋 Getting started with Windows App SDK

👨‍💻 Join in and stay connected

Interested in WinUI and Windows App SDK? Come join us on the quarterly WinUI Community Calls. You can find and tag us on X using #WindowsAppSDK.

🖼️ WinUI 3 Gallery

Make sure to also check out the WinUI 3 Gallery, our interactive sample experience showing everything you can do with WinUI and Windows App SDK.

📢 Contributing

  • File a new issue: Tell us what problem you're trying to solve, how you've tried to solve it so far, and what would be the ideal solution for your app. Bonus points if there's a gist or existing repo we can look at with you.
  • Ask a question: Also, have a look at our FAQ on WinAppSDK page, which we will update periodically.
  • Start a discussion: Let's start a Discussion issue to see if others are interested in a cool new idea you've been thinking about that isn't quite ready to be filed as a more formal Feature Proposal.
  • Code contributions: See our contributing guidelines.

Data collection

This project collects usage data and sends it to Microsoft to help improve our products and services. Note, however, that no data collection is performed when using your private builds.

Privacy information can be found at https://privacy.microsoft.com

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct.

For more information see the Code of Conduct FAQ or contact [email protected] with any additional questions or comments.

Licensing

This project is licensed under the terms in LICENSE.

The .github/skills/ directory contains GitHub Copilot agent skills that may have their own licensing terms. Check each skill's directory for its license file.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .github/skills/issue-triage-report/SKILL.md7.8 KBupstream ↗
    ---
    name: issue-triage-report
    description: Generate comprehensive GitHub Feature Area Status reports for the Windows App SDK repository. Use when asked to create triage reports, identify high-priority issues, analyze feature area health, find issues needing attention, or generate status dashboards. Triggers on requests involving issue triage, area status, priority analysis, bug tracking reports, or engineering team focus areas.
    license: Complete terms in LICENSE.txt
    ---
    
    # Issue Triage Report Generator
    
    This skill generates comprehensive GitHub Feature Area Status reports that help engineering teams identify high-priority issues, track triage status, and highlight items needing immediate attention.
    
    ## When to Use This Skill
    
    **Primary triggers** — Generate a report when:
    
    1. **Engineering triage meetings** — Create status reports showing open issues, needs-triage counts, and highlighted issues per feature area.
    
    2. **Priority analysis requests** — Identify which issues should get engineering focus based on deterministic scoring (reactions, age, comments) plus agent content assessment.
    
    3. **Feature area health checks** — Assess the health of specific areas by analyzing issue distribution, triage backlog, and proposal counts.
    
    4. **Dashboard generation** — Produce markdown tables or formatted reports for team communication channels.
    
    **Anti-patterns** — Do NOT use this skill when:
    - Looking for a specific issue by number (use GitHub search directly)
    - Creating or editing issues (use GitHub MCP tools)
    - Analyzing code changes or PRs (use PR management tools)
    
    ## Prerequisites
    
    - GitHub CLI (`gh`) installed and authenticated
    - PowerShell 5.1+ (Windows) or PowerShell Core (cross-platform)
    - Access to the target GitHub repository (microsoft/WindowsAppSDK)
    - **Area contacts configuration** (see below)
    
    ### Setting Up Area Contacts
    
    The area contacts file maps feature areas to team members. This file is **required** for contact lookups and is stored in your local `.user/` folder (not committed to the repository).
    
    1. Create the directory structure:
       ```powershell
       mkdir -p .user/issue-triage-report
       ```
    
    2. Copy the template and customize:
       ```powershell
       cp .github/skills/issue-triage-report/references/area-contacts.json .user/issue-triage-report/area-contacts.json
       ```
    
    3. Edit `.user/issue-triage-report/area-contacts.json` with your team's actual contacts
    
    > **Note**: The `.user/` folder is gitignored, so your team contacts remain private.
    
    ## Available Scripts
    
    ### Generate-FeatureAreaReport.ps1
    
    Generate the full feature area status report with highlight scoring.
    
    **Location**: `./scripts/Generate-FeatureAreaReport.ps1`
    
    ```powershell
    ./scripts/Generate-FeatureAreaReport.ps1 [-Repo <owner/repo>] [-OutputFormat <markdown|csv|json>] [-HighlightCount <n>]
    ```
    
    | Parameter | Required | Default | Description |
    |-----------|----------|---------|-------------|
    | `-Repo` | No | `microsoft/WindowsAppSDK` | Repository in `owner/repo` format |
    | `-OutputFormat` | No | `markdown` | Output format: `markdown`, `csv`, or `json` |
    | `-HighlightCount` | No | `3` | Max highlighted issues per area |
    | `-IncludeClosed` | No | `$false` | Include recently closed issues count |
    
    **Example**:
    ```powershell
    ./scripts/Generate-FeatureAreaReport.ps1 -OutputFormat markdown -HighlightCount 3
    ```
    
    ---
    
    ### Get-HighlightScore.ps1
    
    Calculate the highlight score for a specific issue to determine priority.
    
    **Location**: `./scripts/Get-HighlightScore.ps1`
    
    ```powershell
    ./scripts/Get-HighlightScore.ps1 -IssueNumber <number> [-Repo <owner/repo>] [-Verbose]
    ```
    
    | Parameter | Required | Default | Description |
    |-----------|----------|---------|-------------|
    | `-IssueNumber` | Yes | - | GitHub issue number to analyze |
    | `-Repo` | No | `microsoft/WindowsAppSDK` | Repository in `owner/repo` format |
    | `-Verbose` | No | `$false` | Show detailed scoring breakdown |
    
    **Example**:
    ```powershell
    ./scripts/Get-HighlightScore.ps1 -IssueNumber 4651 -Verbose
    ```
    
    ---
    
    ### Get-AreaContacts.ps1
    
    Retrieve or update the area-to-contact mapping configuration.
    
    **Location**: `./scripts/Get-AreaContacts.ps1`
    
    ```powershell
    ./scripts/Get-AreaContacts.ps1 [-Area <area-name>] [-Update]
    ```
    
    | Parameter | Required | Default | Description |
    |-----------|----------|---------|-------------|
    | `-Area` | No | - | Specific area to look up (returns all if omitted) |
    | `-Update` | No | `$false` | Interactively update contact mapping |
    
    ## Step-by-Step Workflows
    
    ### Workflow 1: Generate Weekly Triage Report
    
    1. Ensure GitHub CLI is authenticated:
       ```powershell
       gh auth status
       ```
    
    2. Generate the report:
       ```powershell
       ./scripts/Generate-FeatureAreaReport.ps1 -OutputFormat markdown -HighlightCount 3
       ```
    
      Before running the command above, have the agent save runtime assessments to:
      - `./references/AgentAssessments.json`
    
       This file is loaded automatically at script start and applied as per-run overrides.
       Every assessed issue entry must include agent reasoning in the `reasoning` field.
    
       Required per-issue schema in `assessments`:
       - `severityTier`: `critical|high|medium|low|none`
       - `isBlocker`: `true|false`
       - `reasoning`: short rationale explaining severity/blocker judgment
    
       Example:
       ```json
       {
          "assessments": {
             "2894": {
                "severityTier": "high",
                "isBlocker": false,
                "reasoning": "Frequent user impact in notifications flow; clear repro in comments; no confirmed workaround."
             }
          }
       }
       ```
    
    3. Run an agent content review for each highlighted issue using title, body, labels, and comments.
    
    4. Add annotation tags in report narrative: `[severity:critical|high|medium|low|none]`, `[blocker:yes|no]`, and optional `[confidence:XX]`.
    
    5. Copy output to team communication channel (Teams, email, wiki)
    
    ### Workflow 2: Analyze a Specific Feature Area
    
    1. Get area-specific issues:
        ```powershell
        gh issue list --repo microsoft/WindowsAppSDK --label "area-Notifications" --state open --json number,title,body,labels,reactionGroups,createdAt,comments
        ```
    
    2. Check individual issue scores:
       ```powershell
       ./scripts/Get-HighlightScore.ps1 -IssueNumber 2894 -Verbose
       ```
    
    3. Review scoring factors and prioritize accordingly
    
    ### Workflow 3: Update Area Contacts
    
    1. View current contacts:
       ```powershell
       ./scripts/Get-AreaContacts.ps1
       ```
    
    2. Update specific area contact:
       ```powershell
       ./scripts/Get-AreaContacts.ps1 -Area "area-Notifications" -Update
       ```
    
    ## Highlight Scoring Algorithm
    
    Issues are scored with a normalized composite on a `0..100` scale. See [scoring-algorithm.md](./references/scoring-algorithm.md) for complete details.
    
    PowerShell computes deterministic score factors and highlight labels. Severity and blocker are assessment-driven inputs.
    
    Scripts load baseline assessments from:
    
    - `./references/IssueAssessments.json`
    
    They also load runtime agent assessments from:
    
    - `./references/AgentAssessments.json`
    
    If both files include the same issue number, `IssueAssessments.json` takes precedence.
    
    If either file is missing or malformed, scripts emit status/warning output and continue with fallback behavior.
    
    Implementation note: scripts load these files through a single `Read-Assessments` function in `./scripts/ReportLib.ps1` using `-AssessmentType Issue` or `-AssessmentType Agent`.
    
    ## Agent Content Review
    
    After generating scores, review each highlighted issue and assign these annotations based on title, body, labels, and comments:
    
    - `[severity:critical|high|medium|low|none]`
    - `[blocker:yes|no]`
    - `[confidence:XX]`
    
    After assigning annotations, persist the same decision to `./references/AgentAssessments.json` and include `reasoning` for every updated issue entry.
    
    Use this severity rubric:
    
    | Tier | Meaning |
    |------|---------|
    | `critical` | Crash, data loss, severe regression, or broad user/system impact |
    | `high` | Serious functional break affecting key workflows |
    | `
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/microsoft-windowsappsdk-github-skills-issue-triage-report.md

// REPO STATS

4.7k stars
358 open issues
Last commit: 2d ago