devskill 2.0.7 → 2.0.8

package/skills/refactor-method-complexity-reduce/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: refactor-method-complexity-reduce
+description: 'Refactor given method `${input:methodName}` to reduce its cognitive complexity to `${input:complexityThreshold}` or below, by extracting helper methods.'
+---
+
+# Refactor Method to Reduce Cognitive Complexity
+
+## Objective
+Refactor the method `${input:methodName}`, to reduce its cognitive complexity to `${input:complexityThreshold}` or below, by extracting logic into focused helper methods.
+
+## Instructions
+
+1. **Analyze the current method** to identify sources of cognitive complexity:
+   - Nested conditional statements
+   - Multiple if-else or switch chains
+   - Repeated code blocks
+   - Multiple loops with conditions
+   - Complex boolean expressions
+
+2. **Identify extraction opportunities**:
+   - Validation logic that can be extracted into a separate method
+   - Type-specific or case-specific processing that repeats
+   - Complex transformations or calculations
+   - Common patterns that appear multiple times
+
+3. **Extract focused helper methods**:
+   - Each helper should have a single, clear responsibility
+   - Extract validation into separate `Validate*` methods
+   - Extract type-specific logic into handler methods
+   - Create utility methods for common operations
+   - Use appropriate access levels (static, private, async)
+
+4. **Simplify the main method**:
+   - Reduce nesting depth
+   - Replace massive if-else chains with smaller orchestrated calls
+   - Use switch statements where appropriate for cleaner dispatch
+   - Ensure the main method reads as a high-level flow
+
+5. **Preserve functionality**:
+   - Maintain the same input/output behavior
+   - Keep all validation and error handling
+   - Preserve exception types and error messages
+   - Ensure all parameters are properly passed to helpers
+
+6. **Best practices**:
+   - Make helper methods static when they don't need instance state
+   - Use null checks and guard clauses early
+   - Avoid creating unnecessary local variables
+   - Consider using tuples for multiple return values
+   - Group related helper methods together
+
+## Implementation Approach
+
+- Extract helper methods before refactoring the main flow
+- Test incrementally to ensure no regressions
+- Use meaningful names that describe the extracted responsibility
+- Keep extracted methods close to where they're used
+- Consider making repeated code patterns into generic methods
+
+## Result
+
+The refactored method should:
+- Have cognitive complexity reduced to the target threshold of `${input:complexityThreshold}` or below
+- Be more readable and maintainable
+- Have clear separation of concerns
+- Be easier to test and debug
+- Retain all original functionality
+
+## Testing and Validation
+
+**CRITICAL: After completing the refactoring, you MUST:**
+
+1. **Run all existing tests** related to the refactored method and its surrounding functionality
+2. **MANDATORY: Explicitly verify test results show "failed=0"**
+   - **NEVER assume tests passed** - always examine the actual test output
+   - Search for the summary line containing pass/fail counts (e.g., "passed=X failed=Y")
+   - **If the summary shows any number other than "failed=0", tests have FAILED**
+   - If test output is in a file, read the entire file to locate and verify the failure count
+   - Running tests is NOT the same as verifying tests passed
+   - **Do not proceed** until you have explicitly confirmed zero failures
+3. **If any tests fail (failed > 0):**
+   - State clearly how many tests failed
+   - Analyze each failure to understand what functionality was broken
+   - Common causes: null handling, empty collection checks, condition logic errors
+   - Identify the root cause in the refactored code
+   - Correct the refactored code to restore the original behavior
+   - Re-run tests and verify "failed=0" in the output
+   - Repeat until all tests pass (failed=0)
+4. **Verify compilation** - Ensure there are no compilation errors
+5. **Check cognitive complexity** - Confirm the metric is at or below the target threshold of `${input:complexityThreshold}`
+
+## Confirmation Checklist
+- [ ] Code compiles without errors
+- [ ] **Test results explicitly state "failed=0"** (verified by reading the output)
+- [ ] All test failures analyzed and corrected (if any occurred)
+- [ ] Cognitive complexity is at or below the target threshold of `${input:complexityThreshold}`
+- [ ] All original functionality is preserved
+- [ ] Code follows project conventions and standards

package/skills/refactor-method-complexity-reduce/SYNC.md

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

package/skills/refactor-plan/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/refactor-plan/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: refactor-plan
+description: 'Plan a multi-file refactor with proper sequencing and rollback steps'
+---
+
+# Refactor Plan
+
+Create a detailed plan for this refactoring task.
+
+## Refactor Goal
+
+{{refactor_description}}
+
+## Instructions
+
+1. Search the codebase to understand current state
+2. Identify all affected files and their dependencies
+3. Plan changes in a safe sequence (types first, then implementations, then tests)
+4. Include verification steps between changes
+5. Consider rollback if something fails
+
+## Output Format
+
+```markdown
+## Refactor Plan: [title]
+
+### Current State
+[Brief description of how things work now]
+
+### Target State
+[Brief description of how things will work after]
+
+### Affected Files
+| File | Change Type | Dependencies |
+|------|-------------|--------------|
+| path | modify/create/delete | blocks X, blocked by Y |
+
+### Execution Plan
+
+#### Phase 1: Types and Interfaces
+- [ ] Step 1.1: [action] in `file.ts`
+- [ ] Verify: [how to check it worked]
+
+#### Phase 2: Implementation
+- [ ] Step 2.1: [action] in `file.ts`
+- [ ] Verify: [how to check]
+
+#### Phase 3: Tests
+- [ ] Step 3.1: Update tests in `file.test.ts`
+- [ ] Verify: Run `npm test`
+
+#### Phase 4: Cleanup
+- [ ] Remove deprecated code
+- [ ] Update documentation
+
+### Rollback Plan
+If something fails:
+1. [Step to undo]
+2. [Step to undo]
+
+### Risks
+- [Potential issue and mitigation]
+```
+
+Shall I proceed with Phase 1?

package/skills/refactor-plan/SYNC.md

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

package/skills/remember/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/remember/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: remember
+description: 'Transforms lessons learned into domain-organized memory instructions (global or workspace). Syntax: `/remember [>domain [scope]] lesson clue` where scope is `global` (default), `user`, `workspace`, or `ws`.'
+---
+
+# Memory Keeper
+
+You are an expert prompt engineer and keeper of **domain-organized Memory Instructions** that persist across VS Code contexts. You maintain a self-organizing knowledge base that automatically categorizes learnings by domain and creates new memory files as needed.
+
+## Scopes
+
+Memory instructions can be stored in two scopes:
+
+- **Global** (`global` or `user`) - Stored in `<global-prompts>` (`vscode-userdata:/User/prompts/`) and apply to all VS Code projects
+- **Workspace** (`workspace` or `ws`) - Stored in `<workspace-instructions>` (`<workspace-root>/.github/instructions/`) and apply only to the current project
+
+Default scope is **global**.
+
+Throughout this prompt, `<global-prompts>` and `<workspace-instructions>` refer to these directories.
+
+## Your Mission
+
+Transform debugging sessions, workflow discoveries, frequently repeated mistakes, and hard-won lessons into **domain-specific, reusable knowledge**, that helps the agent to effectively find the best patterns and avoid common mistakes. Your intelligent categorization system automatically:
+
+- **Discovers existing memory domains** via glob patterns to find `vscode-userdata:/User/prompts/*-memory.instructions.md` files
+- **Matches learnings to domains** or creates new domain files when needed
+- **Organizes knowledge contextually** so future AI assistants find relevant guidance exactly when needed
+- **Builds institutional memory** that prevents repeating mistakes across all projects
+
+The result: a **self-organizing, domain-driven knowledge base** that grows smarter with every lesson learned.
+
+## Syntax
+
+```
+/remember [>domain-name [scope]] lesson content
+```
+
+- `>domain-name` - Optional. Explicitly target a domain (e.g., `>clojure`, `>git-workflow`)
+- `[scope]` - Optional. One of: `global`, `user` (both mean global), `workspace`, or `ws`. Defaults to `global`
+- `lesson content` - Required. The lesson to remember
+
+**Examples:**
+- `/remember >shell-scripting now we've forgotten about using fish syntax too many times`
+- `/remember >clojure prefer passing maps over parameter lists`
+- `/remember avoid over-escaping`
+- `/remember >clojure workspace prefer threading macros for readability`
+- `/remember >testing ws use setup/teardown functions`
+
+**Use the todo list** to track your progress through the process steps and keep the user informed.
+
+## Memory File Structure
+
+### Description Frontmatter
+Keep domain file descriptions general, focusing on the domain responsibility rather than implementation specifics.
+
+### ApplyTo Frontmatter
+Target specific file patterns and locations relevant to the domain using glob patterns. Keep the glob patterns few and broad, targeting directories if the domain is not specific to a language, or file extensions if the domain is language-specific.
+
+### Main Headline
+Use level 1 heading format: `# <Domain Name> Memory`
+
+### Tag Line
+Follow the main headline with a succinct tagline that captures the core patterns and value of that domain's memory file.
+
+### Learnings
+
+Each distinct lesson has its own level 2 headline
+
+## Process
+
+1. **Parse input** - Extract domain (if `>domain-name` specified) and scope (`global` is default, or `user`, `workspace`, `ws`)
+2. **Glob and Read the start of** existing memory and instruction files to understand current domain structure:
+   - Global: `<global-prompts>/memory.instructions.md`, `<global-prompts>/*-memory.instructions.md`, and `<global-prompts>/*.instructions.md`
+   - Workspace: `<workspace-instructions>/memory.instructions.md`, `<workspace-instructions>/*-memory.instructions.md`, and `<workspace-instructions>/*.instructions.md`
+3. **Analyze** the specific lesson learned from user input and chat session content
+4. **Categorize** the learning:
+   - New gotcha/common mistake
+   - Enhancement to existing section
+   - New best practice
+   - Process improvement
+5. **Determine target domain(s) and file paths**:
+   - If user specified `>domain-name`, request human input if it seems to be a typo
+   - Otherwise, intelligently match learning to a domain, using existing domain files as a guide while recognizing there may be coverage gaps
+   - **For universal learnings:**
+     - Global: `<global-prompts>/memory.instructions.md`
+     - Workspace: `<workspace-instructions>/memory.instructions.md`
+   - **For domain-specific learnings:**
+     - Global: `<global-prompts>/{domain}-memory.instructions.md`
+     - Workspace: `<workspace-instructions>/{domain}-memory.instructions.md`
+   - When uncertain about domain classification, request human input
+6. **Read the domain and domain memory files**
+   - Read to avoid redundancy. Any memories you add should complement existing instructions and memories.
+7. **Update or create memory files**:
+   - Update existing domain memory files with new learnings
+   - Create new domain memory files following [Memory File Structure](#memory-file-structure)
+   - Update `applyTo` frontmatter if needed
+8. **Write** succinct, clear, and actionable instructions:
+   - Instead of comprehensive instructions, think about how to capture the lesson in a succinct and clear manner
+   - **Extract general (within the domain) patterns** from specific instances, the user may want to share the instructions with people for whom the specifics of the learning may not make sense
+   - Instead of “don't”s, use positive reinforcement focusing on correct patterns
+   - Capture:
+      - Coding style, preferences, and workflow
+      - Critical implementation paths
+      - Project-specific patterns
+      - Tool usage patterns
+      - Reusable problem-solving approaches
+
+## Quality Guidelines
+
+- **Generalize beyond specifics** - Extract reusable patterns rather than task-specific details
+- Be specific and concrete (avoid vague advice)
+- Include code examples when relevant
+- Focus on common, recurring issues
+- Keep instructions succinct, scannable, and actionable
+- Clean up redundancy
+- Instructions focus on what to do, not what to avoid
+
+## Update Triggers
+
+Common scenarios that warrant memory updates:
+- Repeatedly forgetting the same shortcuts or commands
+- Discovering effective workflows
+- Learning domain-specific best practices
+- Finding reusable problem-solving approaches
+- Coding style decisions and rationale
+- Cross-project patterns that work well

package/skills/remember/SYNC.md

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

package/skills/remember-interactive-programming/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/remember-interactive-programming/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: remember-interactive-programming
+description: 'A micro-prompt that reminds the agent that it is an interactive programmer. Works great in Clojure when Copilot has access to the REPL (probably via Backseat Driver). Will work with any system that has a live REPL that the agent can use. Adapt the prompt with any specific reminders in your workflow and/or workspace.'
+---
+
+Remember that you are an interactive programmer with the system itself as your source of truth. You use the REPL to explore the current system and to modify the current system in order to understand what changes need to be made.
+
+Remember that the human does not see what you evaluate with the tool:
+* If you evaluate a large amount of code: describe in a succinct way what is being evaluated.
+
+When editing files you prefer to use the structural editing tools.
+
+Also remember to tend your todo list.

package/skills/remember-interactive-programming/SYNC.md

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

package/skills/repo-story-time/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/repo-story-time/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: repo-story-time
+description: 'Generate a comprehensive repository summary and narrative story from commit history'
+---
+
+## Role
+
+You're a senior technical analyst and storyteller with expertise in repository archaeology, code pattern analysis, and narrative synthesis. Your mission is to transform raw repository data into compelling technical narratives that reveal the human stories behind the code.
+
+## Task
+
+Transform any repository into a comprehensive analysis with two deliverables:
+
+1. **REPOSITORY_SUMMARY.md** - Technical architecture and purpose overview
+2. **THE_STORY_OF_THIS_REPO.md** - Narrative story from commit history analysis
+
+**CRITICAL**: You must CREATE and WRITE these files with complete markdown content. Do NOT output the markdown content in the chat - use the `editFiles` tool to create the actual files in the repository root directory.
+
+## Methodology
+
+### Phase 1: Repository Exploration
+
+**EXECUTE these commands immediately** to understand the repository structure and purpose:
+
+1. Get repository overview by running:
+   `Get-ChildItem -Recurse -Include "*.md","*.json","*.yaml","*.yml" | Select-Object -First 20 | Select-Object Name, DirectoryName`
+
+2. Understand project structure by running:
+   `Get-ChildItem -Recurse -Directory | Where-Object {$_.Name -notmatch "(node_modules|\.git|bin|obj)"} | Select-Object -First 30 | Format-Table Name, FullName`
+
+After executing these commands, use semantic search to understand key concepts and technologies. Look for:
+- Configuration files (package.json, pom.xml, requirements.txt, etc.)
+- README files and documentation
+- Main source directories
+- Test directories
+- Build/deployment configurations
+
+### Phase 2: Technical Deep Dive
+Create comprehensive technical inventory:
+- **Purpose**: What problem does this repository solve?
+- **Architecture**: How is the code organized?
+- **Technologies**: What languages, frameworks, and tools are used?
+- **Key Components**: What are the main modules/services/features?
+- **Data Flow**: How does information move through the system?
+
+### Phase 3: Commit History Analysis
+
+**EXECUTE these git commands systematically** to understand repository evolution:
+
+**Step 1: Basic Statistics** - Run these commands to get repository metrics:
+- `git rev-list --all --count` (total commit count)
+- `(git log --oneline --since="1 year ago").Count` (commits in last year)
+
+**Step 2: Contributor Analysis** - Run this command:
+- `git shortlog -sn --since="1 year ago" | Select-Object -First 20`
+
+**Step 3: Activity Patterns** - Run this command:
+- `git log --since="1 year ago" --format="%ai" | ForEach-Object { $_.Substring(0,7) } | Group-Object | Sort-Object Count -Descending | Select-Object -First 12`
+
+**Step 4: Change Pattern Analysis** - Run these commands:
+- `git log --since="1 year ago" --oneline --grep="feat|fix|update|add|remove" | Select-Object -First 50`
+- `git log --since="1 year ago" --name-only --oneline | Where-Object { $_ -notmatch "^[a-f0-9]" } | Group-Object | Sort-Object Count -Descending | Select-Object -First 20`
+
+**Step 5: Collaboration Patterns** - Run this command:
+- `git log --since="1 year ago" --merges --oneline | Select-Object -First 20`
+
+**Step 6: Seasonal Analysis** - Run this command:
+- `git log --since="1 year ago" --format="%ai" | ForEach-Object { $_.Substring(5,2) } | Group-Object | Sort-Object Name`
+
+**Important**: Execute each command and analyze the output before proceeding to the next step.
+**Important**: Use your best judgment to execute additional commands not listed above based on the output of previous commands or the repository's specific content.
+
+### Phase 4: Pattern Recognition
+Look for these narrative elements:
+- **Characters**: Who are the main contributors? What are their specialties?
+- **Seasons**: Are there patterns by month/quarter? Holiday effects?
+- **Themes**: What types of changes dominate? (features, fixes, refactoring)
+- **Conflicts**: Are there areas of frequent change or contention?
+- **Evolution**: How has the repository grown and changed over time?
+
+## Output Format
+
+### REPOSITORY_SUMMARY.md Structure
+```markdown
+# Repository Analysis: [Repo Name]
+
+## Overview
+Brief description of what this repository does and why it exists.
+
+## Architecture
+High-level technical architecture and organization.
+
+## Key Components
+- **Component 1**: Description and purpose
+- **Component 2**: Description and purpose
+[Continue for all major components]
+
+## Technologies Used
+List of programming languages, frameworks, tools, and platforms.
+
+## Data Flow
+How information moves through the system.
+
+## Team and Ownership
+Who maintains different parts of the codebase.
+```
+
+### THE_STORY_OF_THIS_REPO.md Structure
+```markdown
+# The Story of [Repo Name]
+
+## The Chronicles: A Year in Numbers
+Statistical overview of the past year's activity.
+
+## Cast of Characters
+Profiles of main contributors with their specialties and impact.
+
+## Seasonal Patterns
+Monthly/quarterly analysis of development activity.
+
+## The Great Themes
+Major categories of work and their significance.
+
+## Plot Twists and Turning Points
+Notable events, major changes, or interesting patterns.
+
+## The Current Chapter
+Where the repository stands today and future implications.
+```
+
+## Key Instructions
+
+1. **Be Specific**: Use actual file names, commit messages, and contributor names
+2. **Find Stories**: Look for interesting patterns, not just statistics
+3. **Context Matters**: Explain why patterns exist (holidays, releases, incidents)
+4. **Human Element**: Focus on the people and teams behind the code
+5. **Technical Depth**: Balance narrative with technical accuracy
+6. **Evidence-Based**: Support observations with actual git data
+
+## Success Criteria
+
+- Both markdown files are **ACTUALLY CREATED** with complete, comprehensive content using the `editFiles` tool
+- **NO markdown content should be output to chat** - all content must be written directly to the files
+- Technical summary accurately represents repository architecture
+- Narrative story reveals human patterns and interesting insights
+- Git commands provide concrete evidence for all claims
+- Analysis reveals both technical and cultural aspects of development
+- Files are ready to use immediately without any copy/paste from chat dialog
+
+## Critical Final Instructions
+
+**DO NOT** output markdown content in the chat. **DO** use the `editFiles` tool to create both files with complete content. The deliverables are the actual files, not chat output.
+
+Remember: Every repository tells a story. Your job is to uncover that story through systematic analysis and present it in a way that both technical and non-technical audiences can appreciate.

package/skills/repo-story-time/SYNC.md

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

package/skills/review-and-refactor/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/review-and-refactor/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: review-and-refactor
+description: 'Review and refactor code in your project according to defined instructions'
+---
+
+## Role
+
+You're a senior expert software engineer with extensive experience in maintaining projects over a long time and ensuring clean code and best practices. 
+
+## Task
+
+1. Take a deep breath, and review all coding guidelines instructions in `.github/instructions/*.md` and `.github/copilot-instructions.md`, then review all the code carefully and make code refactorings if needed.
+2. The final code should be clean and maintainable while following the specified coding standards and instructions.
+3. Do not split up the code, keep the existing files intact.
+4. If the project includes tests, ensure they are still passing after your changes.

package/skills/review-and-refactor/SYNC.md

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

package/skills/reviewing-oracle-to-postgres-migration/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.