devskill 2.0.6 → 2.0.8

package/skills/project-workflow-analysis-blueprint-generator/SKILL.md

@@ -0,0 +1,293 @@
+---
+name: project-workflow-analysis-blueprint-generator
+description: 'Comprehensive technology-agnostic prompt generator for documenting end-to-end application workflows. Automatically detects project architecture patterns, technology stacks, and data flow patterns to generate detailed implementation blueprints covering entry points, service layers, data access, error handling, and testing approaches across multiple technologies including .NET, Java/Spring, React, and microservices architectures.'
+---
+
+# Project Workflow Documentation Generator
+
+## Configuration Variables
+
+```
+${PROJECT_TYPE="Auto-detect|.NET|Java|Spring|Node.js|Python|React|Angular|Microservices|Other"}
+<!-- Primary technology stack -->
+
+${ENTRY_POINT="API|GraphQL|Frontend|CLI|Message Consumer|Scheduled Job|Custom"}
+<!-- Starting point for the flow -->
+
+${PERSISTENCE_TYPE="Auto-detect|SQL Database|NoSQL Database|File System|External API|Message Queue|Cache|None"}
+<!-- Data storage type -->
+
+${ARCHITECTURE_PATTERN="Auto-detect|Layered|Clean|CQRS|Microservices|MVC|MVVM|Serverless|Event-Driven|Other"}
+<!-- Primary architecture pattern -->
+
+${WORKFLOW_COUNT=1-5}
+<!-- Number of workflows to document -->
+
+${DETAIL_LEVEL="Standard|Implementation-Ready"}
+<!-- Level of implementation detail to include -->
+
+${INCLUDE_SEQUENCE_DIAGRAM=true|false}
+<!-- Generate sequence diagram -->
+
+${INCLUDE_TEST_PATTERNS=true|false}
+<!-- Include testing approach -->
+```
+
+## Generated Prompt
+
+```
+"Analyze the codebase and document ${WORKFLOW_COUNT} representative end-to-end workflows 
+that can serve as implementation templates for similar features. Use the following approach:
+```
+
+### Initial Detection Phase
+
+```
+${PROJECT_TYPE == "Auto-detect" ? 
+  "Begin by examining the codebase structure to identify technologies:
+   - Check for .NET solutions/projects, Spring configurations, Node.js/Express files, etc.
+   - Identify the primary programming language(s) and frameworks in use
+   - Determine the architectural patterns based on folder structure and key components" 
+  : "Focus on ${PROJECT_TYPE} patterns and conventions"}
+```
+
+```
+${ENTRY_POINT == "Auto-detect" ? 
+  "Identify typical entry points by looking for:
+   - API controllers or route definitions
+   - GraphQL resolvers
+   - UI components that initiate network requests
+   - Message handlers or event subscribers
+   - Scheduled job definitions" 
+  : "Focus on ${ENTRY_POINT} entry points"}
+```
+
+```
+${PERSISTENCE_TYPE == "Auto-detect" ? 
+  "Determine persistence mechanisms by examining:
+   - Database context/connection configurations
+   - Repository implementations
+   - ORM mappings
+   - External API clients
+   - File system interactions" 
+  : "Focus on ${PERSISTENCE_TYPE} interactions"}
+```
+
+### Workflow Documentation Instructions
+
+For each of the `${WORKFLOW_COUNT}` most representative workflow(s) in the system:
+
+#### 1. Workflow Overview
+   - Provide a name and brief description of the workflow
+   - Explain the business purpose it serves
+   - Identify the triggering action or event
+   - List all files/classes involved in the complete workflow
+
+#### 2. Entry Point Implementation
+
+**API Entry Points:**
+```
+${ENTRY_POINT == "API" || ENTRY_POINT == "Auto-detect" ? 
+  "- Document the API controller class and method that receives the request
+   - Show the complete method signature including attributes/annotations
+   - Include the full request DTO/model class definition
+   - Document validation attributes and custom validators
+   - Show authentication/authorization attributes and checks" : ""}
+```
+
+**GraphQL Entry Points:**
+```
+${ENTRY_POINT == "GraphQL" || ENTRY_POINT == "Auto-detect" ? 
+  "- Document the GraphQL resolver class and method
+   - Show the complete schema definition for the query/mutation
+   - Include input type definitions
+   - Show resolver method implementation with parameter handling" : ""}
+```
+
+**Frontend Entry Points:**
+```
+${ENTRY_POINT == "Frontend" || ENTRY_POINT == "Auto-detect" ? 
+  "- Document the component that initiates the API call
+   - Show the event handler that triggers the request
+   - Include the API client service method
+   - Show state management code related to the request" : ""}
+```
+
+**Message Consumer Entry Points:**
+```
+${ENTRY_POINT == "Message Consumer" || ENTRY_POINT == "Auto-detect" ? 
+  "- Document the message handler class and method
+   - Show message subscription configuration
+   - Include the complete message model definition
+   - Show deserialization and validation logic" : ""}
+```
+
+#### 3. Service Layer Implementation
+   - Document each service class involved with their dependencies
+   - Show the complete method signatures with parameters and return types
+   - Include actual method implementations with key business logic
+   - Document interface definitions where applicable
+   - Show dependency injection registration patterns
+
+**CQRS Patterns:**
+```
+${ARCHITECTURE_PATTERN == "CQRS" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
+  "- Include complete command/query handler implementations" : ""}
+```
+
+**Clean Architecture Patterns:**
+```
+${ARCHITECTURE_PATTERN == "Clean" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
+  "- Show use case/interactor implementations" : ""}
+```
+
+#### 4. Data Mapping Patterns
+   - Document DTO to domain model mapping code
+   - Show object mapper configurations or manual mapping methods
+   - Include validation logic during mapping
+   - Document any domain events created during mapping
+
+#### 5. Data Access Implementation
+   - Document repository interfaces and their implementations
+   - Show complete method signatures with parameters and return types
+   - Include actual query implementations
+   - Document entity/model class definitions with all properties
+   - Show transaction handling patterns
+
+**SQL Database Patterns:**
+```
+${PERSISTENCE_TYPE == "SQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
+  "- Include ORM configurations, annotations, or Fluent API usage
+   - Show actual SQL queries or ORM statements" : ""}
+```
+
+**NoSQL Database Patterns:**
+```
+${PERSISTENCE_TYPE == "NoSQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
+  "- Show document structure definitions
+   - Include document query/update operations" : ""}
+```
+
+#### 6. Response Construction
+   - Document response DTO/model class definitions
+   - Show mapping from domain/entity models to response models
+   - Include status code selection logic
+   - Document error response structure and generation
+
+#### 7. Error Handling Patterns
+   - Document exception types used in the workflow
+   - Show try/catch patterns at each layer
+   - Include global exception handler configurations
+   - Document error logging implementations
+   - Show retry policies or circuit breaker patterns
+   - Include compensating actions for failure scenarios
+
+#### 8. Asynchronous Processing Patterns
+   - Document background job scheduling code
+   - Show event publication implementations
+   - Include message queue sending patterns
+   - Document callback or webhook implementations
+   - Show how async operations are tracked and monitored
+
+**Testing Approach (Optional):**
+```
+${INCLUDE_TEST_PATTERNS ? 
+  "9. **Testing Approach**
+     - Document unit test implementations for each layer
+     - Show mocking patterns and test fixture setup
+     - Include integration test implementations
+     - Document test data generation approaches
+     - Show API/controller test implementations" : ""}
+```
+
+**Sequence Diagram (Optional):**
+```
+${INCLUDE_SEQUENCE_DIAGRAM ? 
+  "10. **Sequence Diagram**
+      - Generate a detailed sequence diagram showing all components
+      - Include method calls with parameter types
+      - Show return values between components
+      - Document conditional flows and error paths" : ""}
+```
+
+#### 11. Naming Conventions
+Document consistent patterns for:
+- Controller naming (e.g., `EntityNameController`)
+- Service naming (e.g., `EntityNameService`)
+- Repository naming (e.g., `IEntityNameRepository`)
+- DTO naming (e.g., `EntityNameRequest`, `EntityNameResponse`)
+- Method naming patterns for CRUD operations
+- Variable naming conventions
+- File organization patterns
+
+#### 12. Implementation Templates
+Provide reusable code templates for:
+- Creating a new API endpoint following the pattern
+- Implementing a new service method
+- Adding a new repository method
+- Creating new domain model classes
+- Implementing proper error handling
+
+### Technology-Specific Implementation Patterns
+
+**.NET Implementation Patterns (if detected):**
+```
+${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? 
+  "- Complete controller class with attributes, filters, and dependency injection
+   - Service registration in Startup.cs or Program.cs
+   - Entity Framework DbContext configuration
+   - Repository implementation with EF Core or Dapper
+   - AutoMapper profile configurations
+   - Middleware implementations for cross-cutting concerns
+   - Extension method patterns
+   - Options pattern implementation for configuration
+   - Logging implementation with ILogger
+   - Authentication/authorization filter or policy implementations" : ""}
+```
+
+**Spring Implementation Patterns (if detected):**
+```
+${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Spring" || PROJECT_TYPE == "Auto-detect" ? 
+  "- Complete controller class with annotations and dependency injection
+   - Service implementation with transaction boundaries
+   - Repository interface and implementation
+   - JPA entity definitions with relationships
+   - DTO class implementations
+   - Bean configuration and component scanning
+   - Exception handler implementations
+   - Custom validator implementations" : ""}
+```
+
+**React Implementation Patterns (if detected):**
+```
+${PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect" ? 
+  "- Component structure with props and state
+   - Hook implementation patterns (useState, useEffect, custom hooks)
+   - API service implementation
+   - State management patterns (Context, Redux)
+   - Form handling implementations
+   - Route configuration" : ""}
+```
+
+### Implementation Guidelines
+
+Based on the documented workflows, provide specific guidance for implementing new features:
+
+#### 1. Step-by-Step Implementation Process
+- Where to start when adding a similar feature
+- Order of implementation (e.g., model → repository → service → controller)
+- How to integrate with existing cross-cutting concerns
+
+#### 2. Common Pitfalls to Avoid
+- Identify error-prone areas in the current implementation
+- Note performance considerations
+- List common bugs or issues encountered
+
+#### 3. Extension Mechanisms
+- Document how to plug into existing extension points
+- Show how to add new behavior without modifying existing code
+- Explain configuration-driven feature patterns
+
+**Conclusion:**
+Conclude with a summary of the most important patterns that should be followed when 
+implementing new features to maintain consistency with the codebase."

package/skills/project-workflow-analysis-blueprint-generator/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/project-workflow-analysis-blueprint-generator`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/prompt-builder/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/prompt-builder/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: prompt-builder
+description: 'Guide users through creating high-quality GitHub Copilot prompts with proper structure, tools, and best practices.'
+---
+
+# Professional Prompt Builder
+
+You are an expert prompt engineer specializing in GitHub Copilot prompt development with deep knowledge of:
+- Prompt engineering best practices and patterns
+- VS Code Copilot customization capabilities  
+- Effective persona design and task specification
+- Tool integration and front matter configuration
+- Output format optimization for AI consumption
+
+Your task is to guide me through creating a new `.prompt.md` file by systematically gathering requirements and generating a complete, production-ready prompt file.
+
+## Discovery Process
+
+I will ask you targeted questions to gather all necessary information. After collecting your responses, I will generate the complete prompt file content following established patterns from this repository.
+
+### 1. **Prompt Identity & Purpose**
+- What is the intended filename for your prompt (e.g., `generate-react-component.prompt.md`)?
+- Provide a clear, one-sentence description of what this prompt accomplishes
+- What category does this prompt fall into? (code generation, analysis, documentation, testing, refactoring, architecture, etc.)
+
+### 2. **Persona Definition**
+- What role/expertise should Copilot embody? Be specific about:
+    - Technical expertise level (junior, senior, expert, specialist)
+    - Domain knowledge (languages, frameworks, tools)
+    - Years of experience or specific qualifications
+    - Example: "You are a senior .NET architect with 10+ years of experience in enterprise applications and extensive knowledge of C# 12, ASP.NET Core, and clean architecture patterns"
+
+### 3. **Task Specification**
+- What is the primary task this prompt performs? Be explicit and measurable
+- Are there secondary or optional tasks?
+- What should the user provide as input? (selection, file, parameters, etc.)
+- What constraints or requirements must be followed?
+
+### 4. **Context & Variable Requirements**
+- Will it use `${selection}` (user's selected code)?
+- Will it use `${file}` (current file) or other file references?
+- Does it need input variables like `${input:variableName}` or `${input:variableName:placeholder}`?
+- Will it reference workspace variables (`${workspaceFolder}`, etc.)?
+- Does it need to access other files or prompt files as dependencies?
+
+### 5. **Detailed Instructions & Standards**
+- What step-by-step process should Copilot follow?
+- Are there specific coding standards, frameworks, or libraries to use?
+- What patterns or best practices should be enforced?
+- Are there things to avoid or constraints to respect?
+- Should it follow any existing instruction files (`.instructions.md`)?
+
+### 6. **Output Requirements**
+- What format should the output be? (code, markdown, JSON, structured data, etc.)
+- Should it create new files? If so, where and with what naming convention?
+- Should it modify existing files?
+- Do you have examples of ideal output that can be used for few-shot learning?
+- Are there specific formatting or structure requirements?
+
+### 7. **Tool & Capability Requirements**
+Which tools does this prompt need? Common options include:
+- **File Operations**: `codebase`, `editFiles`, `search`, `problems`
+- **Execution**: `runCommands`, `runTasks`, `runTests`, `terminalLastCommand`
+- **External**: `fetch`, `githubRepo`, `openSimpleBrowser`
+- **Specialized**: `playwright`, `usages`, `vscodeAPI`, `extensions`
+- **Analysis**: `changes`, `findTestFiles`, `testFailure`, `searchResults`
+
+### 8. **Technical Configuration**
+- Should this run in a specific mode? (`agent`, `ask`, `edit`)
+- Does it require a specific model? (usually auto-detected)
+- Are there any special requirements or constraints?
+
+### 9. **Quality & Validation Criteria**
+- How should success be measured?
+- What validation steps should be included?
+- Are there common failure modes to address?
+- Should it include error handling or recovery steps?
+
+## Best Practices Integration
+
+Based on analysis of existing prompts, I will ensure your prompt includes:
+
+✅ **Clear Structure**: Well-organized sections with logical flow
+✅ **Specific Instructions**: Actionable, unambiguous directions  
+✅ **Proper Context**: All necessary information for task completion
+✅ **Tool Integration**: Appropriate tool selection for the task
+✅ **Error Handling**: Guidance for edge cases and failures
+✅ **Output Standards**: Clear formatting and structure requirements
+✅ **Validation**: Criteria for measuring success
+✅ **Maintainability**: Easy to update and extend
+
+## Next Steps
+
+Please start by answering the questions in section 1 (Prompt Identity & Purpose). I'll guide you through each section systematically, then generate your complete prompt file.
+
+## Template Generation
+
+After gathering all requirements, I will generate a complete `.prompt.md` file following this structure:
+
+```markdown
+---
+description: "[Clear, concise description from requirements]"
+agent: "[agent|ask|edit based on task type]"
+tools: ["[appropriate tools based on functionality]"]
+model: "[only if specific model required]"
+---
+
+# [Prompt Title]
+
+[Persona definition - specific role and expertise]
+
+## [Task Section]
+[Clear task description with specific requirements]
+
+## [Instructions Section]
+[Step-by-step instructions following established patterns]
+
+## [Context/Input Section] 
+[Variable usage and context requirements]
+
+## [Output Section]
+[Expected output format and structure]
+
+## [Quality/Validation Section]
+[Success criteria and validation steps]
+```
+
+The generated prompt will follow patterns observed in high-quality prompts like:
+- **Comprehensive blueprints** (architecture-blueprint-generator)
+- **Structured specifications** (create-github-action-workflow-specification)  
+- **Best practice guides** (dotnet-best-practices, csharp-xunit)
+- **Implementation plans** (create-implementation-plan)
+- **Code generation** (playwright-generate-test)
+
+Each prompt will be optimized for:
+- **AI Consumption**: Token-efficient, structured content
+- **Maintainability**: Clear sections, consistent formatting
+- **Extensibility**: Easy to modify and enhance
+- **Reliability**: Comprehensive instructions and error handling
+
+Please start by telling me the name and description for the new prompt you want to build.

package/skills/prompt-builder/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/prompt-builder`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/publish-to-pages/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/publish-to-pages/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: publish-to-pages
+description: 'Publish presentations and web content to GitHub Pages. Converts PPTX, PDF, HTML, or Google Slides to a live GitHub Pages URL. Handles repo creation, file conversion, Pages enablement, and returns the live URL. Use when the user wants to publish, deploy, or share a presentation or HTML file via GitHub Pages.'
+---
+
+# publish-to-pages
+
+Publish any presentation or web content to GitHub Pages in one shot.
+
+## 1. Prerequisites Check
+
+Run these silently. Only surface errors:
+
+```bash
+command -v gh >/dev/null || echo "MISSING: gh CLI — install from https://cli.github.com"
+gh auth status &>/dev/null || echo "MISSING: gh not authenticated — run 'gh auth login'"
+command -v python3 >/dev/null || echo "MISSING: python3 (needed for PPTX conversion)"
+```
+
+`poppler-utils` is optional (PDF conversion via `pdftoppm`). Don't block on it.
+
+## 2. Input Detection
+
+Determine input type from what the user provides:
+
+| Input | Detection |
+|-------|-----------|
+| HTML file | Extension `.html` or `.htm` |
+| PPTX file | Extension `.pptx` |
+| PDF file | Extension `.pdf` |
+| Google Slides URL | URL contains `docs.google.com/presentation` |
+
+Ask the user for a **repo name** if not provided. Default: filename without extension.
+
+## 3. Conversion
+
+### Large File Handling
+
+Both conversion scripts automatically detect large files and switch to **external assets mode**:
+- **PPTX:** Files >20MB or with >50 images → images saved as separate files in `assets/`
+- **PDF:** Files >20MB or with >50 pages → page PNGs saved in `assets/`
+- Files >150MB print a warning (PPTX suggests PDF path instead)
+
+This keeps individual files well under GitHub's 100MB limit. Small files still produce a single self-contained HTML.
+
+You can force the behavior with `--external-assets` or `--no-external-assets`.
+
+### HTML
+No conversion needed. Use the file directly as `index.html`.
+
+### PPTX
+Run the conversion script:
+```bash
+python3 SKILL_DIR/scripts/convert-pptx.py INPUT_FILE /tmp/output.html
+# For large files, force external assets:
+python3 SKILL_DIR/scripts/convert-pptx.py INPUT_FILE /tmp/output.html --external-assets
+```
+If `python-pptx` is missing, tell the user: `pip install python-pptx`
+
+### PDF
+Convert with the included script (requires `poppler-utils` for `pdftoppm`):
+```bash
+python3 SKILL_DIR/scripts/convert-pdf.py INPUT_FILE /tmp/output.html
+# For large files, force external assets:
+python3 SKILL_DIR/scripts/convert-pdf.py INPUT_FILE /tmp/output.html --external-assets
+```
+Each page is rendered as a PNG and embedded into HTML with slide navigation.
+If `pdftoppm` is missing, tell the user: `apt install poppler-utils` (or `brew install poppler` on macOS).
+
+### Google Slides
+1. Extract the presentation ID from the URL (the long string between `/d/` and `/`)
+2. Download as PPTX:
+```bash
+curl -L "https://docs.google.com/presentation/d/PRESENTATION_ID/export/pptx" -o /tmp/slides.pptx
+```
+3. Then convert the PPTX using the convert script above.
+
+## 4. Publishing
+
+### Visibility
+Repos are created **public** by default. If the user specifies `private` (or wants a private repo), use `--private` — but note that GitHub Pages on private repos requires a Pro, Team, or Enterprise plan.
+
+### Publish
+```bash
+bash SKILL_DIR/scripts/publish.sh /path/to/index.html REPO_NAME public "Description"
+```
+
+Pass `private` instead of `public` if the user requests it.
+
+The script creates the repo, pushes `index.html` (plus `assets/` if present), and enables GitHub Pages.
+
+**Note:** When external assets mode is used, the output HTML references files in `assets/`. The publish script automatically detects and copies the `assets/` directory alongside the HTML file. Make sure the HTML file and its `assets/` directory are in the same parent directory.
+
+## 5. Output
+
+Tell the user:
+- **Repository:** `https://github.com/USERNAME/REPO_NAME`
+- **Live URL:** `https://USERNAME.github.io/REPO_NAME/`
+- **Note:** Pages takes 1-2 minutes to go live.
+
+## Error Handling
+
+- **Repo already exists:** Suggest appending a number (`my-slides-2`) or a date (`my-slides-2026`).
+- **Pages enablement fails:** Still return the repo URL. User can enable Pages manually in repo Settings.
+- **PPTX conversion fails:** Tell user to run `pip install python-pptx`.
+- **PDF conversion fails:** Suggest installing `poppler-utils` (`apt install poppler-utils` or `brew install poppler`).
+- **Google Slides download fails:** The presentation may not be publicly accessible. Ask user to make it viewable or download the PPTX manually.

package/skills/publish-to-pages/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/publish-to-pages`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24