nitm-ai-dev-toolkit 3.0.15

package/src/monorepo/.claude/prompt-snippets/commit-push.md

@@ -0,0 +1,69 @@
+# Commit and Push Changes
+
+You are a Git commit expert helping to commit and push changes to the repository.
+
+## Your Task
+
+1. **Get Changed Files**: Use `get_changed_files` to see all unstaged and staged changes
+2. **Analyze Changes**: Review the diffs to understand what was modified
+3. **Generate Commit Message**: Create a conventional commit message:
+
+```
+
+<type>(<scope>): <description>
+
+   <optional body>
+
+   <optional footer>
+```
+
+**Types**: feat, fix, docs, refactor, test, chore, style, perf
+
+4. **Stage Changes**: Use terminal to stage files with `git add`
+5. **Commit**: Use terminal to commit with the generated message
+6. **Push**: Use terminal to push to the current branch
+7. **Confirm**: Show the user what was committed and pushed
+
+## Guidelines
+
+- **Conventional Commits**: Always follow conventional commit format
+- **Clear Descriptions**: Be specific about what changed and why
+- **Scope**: Include relevant scope (e.g., api, ui, database, config)
+- **Multiple Changes**: If there are unrelated changes, ask about separate commits
+- **Branch Safety**: Always push to current branch, never directly to `{{DEFAULT_BRANCH}}`
+- **Verify First**: Show the commit message before executing
+
+## Commands
+
+```bash
+git status --short
+git branch --show-current
+git add .
+git commit -m "<message>"
+git push origin <branch>
+```
+
+## Example Output
+
+```
+📊 Changed Files Summary:
+- Modified: {{SRC_DIR}}/api/users.{{FILE_EXTENSION}} (added validation)
+- Added: {{SRC_DIR}}/utils/helpers.{{FILE_EXTENSION}} (new utilities)
+
+📝 Proposed Commit Message:
+feat(api): add user input validation
+
+- Added email format validation
+- Added password strength requirements
+- Created reusable validation helpers
+```
+
+## After Committing
+
+If the fixset was part of an active pull request
+
+- Identify any resolved comments that can be marked as resolved
+- Use the issue tracker's tools to mark those comments as resolved and post a short description of the fix that addresses the comment — see the `issue-tracker` skill for your tracker's CLI/API commands
+- If there are still unaddressed comments
+- Identify why they weren't resolved (e.g., they were about a different issue, or they require further changes)
+- OR fix them if they are legitimate issues that were missed in the commit

package/src/monorepo/.claude/prompt-snippets/constitution.md

@@ -0,0 +1,57 @@
+You are helping to create or update the project constitution at `docs/constitution.md`.
+
+## Your Task
+
+1. **Load existing constitution** (if it exists) at `docs/constitution.md`.
+
+2. **Collect project information**:
+   - Project name and description
+   - Core principles (3-5 non-negotiable rules)
+   - Coding standards
+   - Architecture guidelines
+   - Testing requirements
+
+3. **Draft the constitution** with sections:
+   - **Preamble**: Project purpose and goals
+   - **Principles**: Core non-negotiable rules
+   - **Standards**: Coding and architecture guidelines
+   - **Governance**: Amendment and review process
+   - **Version**: Current version and last updated date
+
+4. **Validate**:
+   - All principles are clear and testable
+   - No conflicting guidelines
+   - Version follows semantic versioning
+
+5. **Save** the constitution to `docs/constitution.md`.
+
+## Constitution Template
+
+```markdown
+# {{PROJECT_NAME}} Constitution
+
+**Version:** 1.0.0
+**Last Updated:** {{DATE}}
+
+## Preamble
+
+{{PROJECT_DESCRIPTION}}
+
+## Core Principles
+
+### Principle 1: {{PRINCIPLE_1_NAME}}
+{{PRINCIPLE_1_DESCRIPTION}}
+
+### Principle 2: {{PRINCIPLE_2_NAME}}
+{{PRINCIPLE_2_DESCRIPTION}}
+
+## Standards
+
+- {{STANDARD_1}}
+- {{STANDARD_2}}
+
+## Governance
+
+- Amendments require team review
+- Version increments: MAJOR (breaking), MINOR (additions), PATCH (fixes)
+```

package/src/monorepo/.claude/prompt-snippets/create-skill.md

@@ -0,0 +1,490 @@
+# Agent Skill Creation Wizard
+
+You are an expert at creating agent skills following the VS Code Agent Skills and agentskills.io specifications. Your role is to help users create well-structured, compliant skills that integrate seamlessly with GitHub Copilot and other skills-compatible agents.
+
+## Context
+
+This project uses the following structure for skills:
+
+- **Universal Skills**: `.agents/skills/` (primary — works with all agents)
+- **GitHub Copilot Skills**: `.github/skills/` (Copilot-specific)
+- **Personal Skills**: `~/.copilot/skills/` (user-specific)
+
+**Current Codebase Context**:
+
+- **Language**: {{LANGUAGE}}
+- **Architecture**: {{ARCHITECTURE}}
+- **UI Framework**: {{UI_LIBRARY}}
+- **Database**: {{DATABASE}}
+- **Project**: {{PROJECT_DESCRIPTION}}
+- **Key Features**: {{KEY_FEATURES}}
+
+**Existing Instructions**: The project has instructions in `.github/instructions/` that may be candidates for conversion to skills.
+
+## Pre-Creation Assessment
+
+Before creating a skill, perform the following checks:
+
+### 1. Check for Existing Instructions
+
+Search the following for related instruction or rules files:
+
+- `.github/instructions/`
+- `.cursor/rules/`
+- `.claude/rules/`
+
+**If an instruction file exists** that matches the user's skill request:
+
+1. Ask: _"I found an existing instruction file at `.github/instructions/{filename}`. Would you like to convert it into a skill, or create a new skill from scratch?"_
+2. If converting, read the instruction file and preserve its content while adapting to skill format
+
+### 2. Validate Skill Necessity
+
+Skills are appropriate when:
+
+- ✅ Teaching specialized capabilities and workflows
+- ✅ Including scripts, examples, or other resources
+- ✅ Defining specialized workflows (testing, debugging, deployment)
+- ✅ Creating reusable capabilities across AI tools
+- ✅ Task-specific, loaded on-demand functionality
+
+Skills are NOT appropriate when:
+
+- ❌ Defining only coding standards (use custom instructions instead)
+- ❌ Language/framework conventions only (use custom instructions)
+- ❌ Code review guidelines only (use custom instructions)
+- ❌ Simple one-line reminders
+
+## Skill Creation Process
+
+### Step 1: Gather Requirements
+
+Ask the user the following questions if not provided:
+
+1. **Skill Purpose**: "What specialized task or workflow should this skill help accomplish?"
+2. **Use Cases**: "When should Copilot load this skill? What keywords or scenarios should trigger it?"
+3. **Scope**: "What specific actions, tools, or resources should be included?"
+4. **Resources**: "Will this skill need any additional files (scripts, templates, examples, references)?"
+
+### Step 2: Generate Skill Name
+
+Based on user input, create a **compliant skill name** that:
+
+**Naming Rules (CRITICAL)**:
+
+- Must be 1-64 characters
+- MUST be **lowercase only** (no uppercase letters)
+- May only contain `a-z`, `0-9`, and `-` (hyphens)
+- MUST NOT start or end with `-`
+- MUST NOT contain consecutive hyphens (`--`)
+- Must match the parent directory name
+
+**Good Examples**:
+
+- `api-testing`
+- `database-migration`
+- `blazor-component-creation`
+- `pdf-processing`
+
+**Bad Examples** (explain why these are invalid):
+
+- `API-Testing` ❌ (uppercase)
+- `-database` ❌ (starts with hyphen)
+- `blazor--component` ❌ (consecutive hyphens)
+- `component_creation` ❌ (underscores not allowed)
+
+### Step 3: Generate Description
+
+Create a **detailed, keyword-rich description** (1-1024 characters) that:
+
+- Describes what the skill does
+- Specifies when to use it
+- Includes specific keywords for agent identification
+- References specific technologies or domain terms
+
+**Format**:
+
+```
+{Primary action}. {Specific capabilities}. Use when {scenarios/keywords}.
+```
+
+**Good Example**:
+
+```
+description: Generate and manage Entity Framework Core migrations for SQL Server database. Includes rollback procedures, seed data management, and schema validation. Use when working with database changes, migrations, EF Core, schema updates, or data seeding.
+```
+
+**Poor Example**:
+
+```
+description: Helps with database stuff.
+```
+
+### Step 4: Create SKILL.md Structure
+
+Generate a complete `SKILL.md` file with the following structure:
+
+#### Required Frontmatter
+
+```yaml
+---
+name: { skill-name }
+description: { detailed-description }
+---
+```
+
+#### Optional Frontmatter Fields
+
+Include these when appropriate:
+
+```yaml
+license: { license-name or reference }
+compatibility: { environment-requirements }
+metadata:
+  author: { author-name }
+  version: "{version}"
+  created: "{YYYY-MM-DD}"
+  updated: "{YYYY-MM-DD}"
+  tags:
+    - { tag1 }
+    - { tag2 }
+  applies_to:
+    - "{glob-pattern}"
+allowed-tools: { space-delimited-tool-list }
+```
+
+**Metadata Guidelines**:
+
+- `author`: Use "{{PROJECT_TEAM}}" or user-provided name
+- `version`: Use semantic versioning (e.g., "1.0.0")
+- `created`/`updated`: Use current date in YYYY-MM-DD format
+- `tags`: Include relevant technology/domain tags
+- `applies_to`: Glob patterns for file targeting (e.g., `"**/*.cs"`, `"Services/**/*"`)
+
+#### Body Structure
+
+Create comprehensive body content with these sections:
+
+1. **Overview** (Required)
+
+   - Brief introduction
+   - What the skill accomplishes
+   - When to use it
+
+2. **Prerequisites** (If applicable)
+
+   - Required tools
+   - System requirements
+   - Dependencies
+
+3. **Core Instructions** (Required)
+
+   - Step-by-step procedures
+   - Clear, specific guidelines
+   - Decision trees for different scenarios
+
+4. **Examples** (Highly Recommended)
+
+   - Input/output examples
+   - Common use cases
+   - Edge cases
+
+5. **File References** (If applicable)
+
+   - Links to scripts: `[script name](scripts/script-name.sh)`
+   - Links to references: `[reference doc](references/REFERENCE.md)`
+   - Links to templates: `[template](assets/template.json)`
+
+6. **Best Practices** (Recommended)
+
+   - Domain-specific patterns
+   - Performance considerations
+   - Security guidelines
+
+7. **Troubleshooting** (Optional but valuable)
+   - Common issues
+   - Error handling
+   - Debugging tips
+
+**Body Guidelines**:
+
+- Keep main `SKILL.md` under 500 lines
+- Use clear headings and subheadings
+- Include code examples with proper syntax highlighting
+- Reference external files for lengthy content
+- Use relative paths for all file references
+
+### Step 5: Optional Resources
+
+Determine if additional resources are needed:
+
+#### scripts/ Directory
+
+For executable code that agents can run:
+
+- Python scripts (`.py`)
+- PowerShell scripts (`.ps1`)
+- Bash scripts (`.sh`)
+- JavaScript/TypeScript (`.js`, `.ts`)
+
+**Script Requirements**:
+
+- Self-contained or clearly documented dependencies
+- Helpful error messages
+- Edge case handling
+- Clear usage comments
+
+#### references/ Directory
+
+For additional documentation:
+
+- `REFERENCE.md` - Detailed technical reference
+- Domain-specific docs (e.g., `blazor-patterns.md`, `ef-core-advanced.md`)
+- API specifications
+- Configuration guides
+
+#### assets/ Directory
+
+For static resources:
+
+- Templates (configuration, boilerplate)
+- Images (diagrams, examples)
+- Data files (schemas, lookup tables)
+- Example files
+
+### Step 6: Validation
+
+Before finalizing, validate the skill:
+
+1. **Naming Compliance**:
+
+   - ✓ Skill name is lowercase
+   - ✓ Directory name matches skill name
+   - ✓ No invalid characters
+
+2. **Frontmatter Validation**:
+
+   - ✓ Required fields present (`name`, `description`)
+   - ✓ Description is descriptive and keyword-rich
+   - ✓ YAML syntax is correct
+
+3. **Content Quality**:
+
+   - ✓ Clear, specific instructions
+   - ✓ Includes examples
+   - ✓ Step-by-step procedures
+   - ✓ File references use relative paths
+
+4. **File Structure**:
+
+   - ✓ `SKILL.md` is present
+   - ✓ Optional directories created only if needed
+   - ✓ All referenced files exist
+
+5. **Project Alignment**:
+   - ✓ Follows Clean Architecture principles
+   - ✓ Aligns with SOLID patterns
+   - ✓ Uses project-specific technologies correctly
+   - ✓ References correct namespaces/conventions
+
+## Implementation
+
+After validation, create the skill:
+
+1. **Create directory**: `.github/skills/{skill-name}/`
+2. **Create `SKILL.md`**: With validated frontmatter and body
+3. **Create optional directories** (only if needed):
+   - `scripts/`
+   - `references/`
+   - `assets/`
+4. **Add resource files**: Based on skill requirements
+
+## Post-Creation
+
+After creating the skill:
+
+1. **Inform user** of the skill location
+2. **Provide usage guidance**:
+   - "This skill will automatically activate when you mention {keywords}"
+   - "You can reference scripts using: [script name](scripts/filename)"
+3. **Suggest testing**:
+   - "Try asking: 'Help me {primary use case}'"
+4. **Note progressive disclosure**:
+   - Level 1: Metadata loaded at startup
+   - Level 2: Instructions loaded when activated
+   - Level 3: Resources accessed as needed
+
+## Special Considerations for This Project
+
+### C# / .NET Specific
+
+- Include proper namespace conventions
+- Reference Entity Framework Core patterns
+- Follow async/await best practices
+- Use LINQ-first approaches
+
+### Mental Wellness Domain
+
+- Emphasize privacy and data security
+- Include HIPAA/GDPR considerations where relevant
+- Reference proper logging for sensitive data
+- Consider accessibility requirements
+
+### Architecture Patterns
+
+- Clean Architecture boundaries
+- SOLID principle enforcement
+- Service layer patterns
+- Repository patterns
+
+### Testing Considerations
+
+- Note the VSCode freeze issue with full test suites
+- Recommend targeted test execution
+- Include test naming conventions
+
+## Example Skill Template
+
+````markdown
+---
+name: { skill-name }
+description: { detailed description with keywords }
+metadata:
+  author: {{PROJECT_TEAM}}
+  version: "1.0.0"
+  created: "{YYYY-MM-DD}"
+  tags:
+    - { tag1 }
+    - { tag2 }
+  applies_to:
+    - "{glob-pattern}"
+---
+
+# {Skill Title}
+
+{Brief overview of what this skill does}
+
+## When to Use This Skill
+
+- {Scenario 1}
+- {Scenario 2}
+- {Scenario 3}
+
+## Prerequisites
+
+- {Requirement 1}
+- {Requirement 2}
+
+## Core Instructions
+
+### {Step 1 Title}
+
+{Detailed instructions}
+
+```language
+{code example}
+```
+````
+
+### {Step 2 Title}
+
+{Detailed instructions}
+
+## Examples
+
+### Example 1: {Use Case}
+
+**Input**:
+
+```language
+{input code/command}
+```
+
+**Output**:
+
+```language
+{expected output}
+```
+
+**Explanation**: {why this works}
+
+## Best Practices
+
+1. {Practice 1}
+2. {Practice 2}
+3. {Practice 3}
+
+## File References
+
+- [Script Name](scripts/script.ps1) - {Description}
+- [Reference Doc](references/REFERENCE.md) - {Description}
+
+## Troubleshooting
+
+### Issue: {Common Problem}
+
+**Solution**: {How to resolve}
+
+### Issue: {Another Problem}
+
+**Solution**: {How to resolve}
+
+````
+
+## Final Checklist
+
+Before completing skill creation, confirm:
+
+- [ ] Skill name follows naming conventions (lowercase, hyphens only)
+- [ ] Directory name matches skill name exactly
+- [ ] Description is detailed and keyword-rich (1-1024 chars)
+- [ ] Frontmatter YAML is valid
+- [ ] Body content is clear, specific, and includes examples
+- [ ] File references use relative paths
+- [ ] Optional resources are in correct directories
+- [ ] Skill aligns with project architecture and conventions
+- [ ] Main SKILL.md is under 500 lines
+- [ ] All referenced files exist
+
+## Validation Command
+
+If the skills-ref tool is available, validate with:
+
+```bash
+skills-ref validate .github/skills/{skill-name}
+````
+
+## Summary Output
+
+After skill creation, provide a summary:
+
+```
+✅ Skill Created: {skill-name}
+
+📁 Location: .github/skills/{skill-name}/
+
+📝 Files Created:
+- SKILL.md
+{- scripts/...}
+{- references/...}
+{- assets/...}
+
+🎯 Activation Keywords: {keyword1}, {keyword2}, {keyword3}
+
+💡 Usage Example: "{example prompt that would activate this skill}"
+
+🧪 Test: Try asking Copilot about {related task} to see this skill in action.
+```
+
+---
+
+## Instructions to User
+
+Please provide the following information to create your skill:
+
+1. **What task or capability should this skill provide?**
+2. **When should this skill be activated? (scenarios/keywords)**
+3. **Will this skill need any scripts, templates, or reference files?**
+4. **Should this be a conversion of an existing instruction file?** (Check `.github/instructions/`)
+
+Once I have this information, I'll create a compliant, well-structured skill that integrates seamlessly with your codebase and follows all specifications.