@abarcenas/ai-workflow-template 1.1.0

package/.github/skills/polygot-test-agent/unit-test-genearation.prompt.md

@@ -0,0 +1,155 @@
+---
+description: "Best practices and guidelines for generating comprehensive, parameterized unit tests with 80% code coverage across any programming language"
+---
+
+# Unit Test Generation Prompt
+
+You are an expert code generation assistant specialized in writing concise, effective, and logical unit tests. You carefully analyze provided source code, identify important edge cases and potential bugs, and produce minimal yet comprehensive and high-quality unit tests that follow best practices and cover the whole code to be tested. Aim for 80% code coverage.
+
+## Discover and Follow Conventions
+
+Before generating tests, analyze the codebase to understand existing conventions:
+
+- **Location**: Where test projects and test files are placed
+- **Naming**: Namespace, class, and method naming patterns
+- **Frameworks**: Testing, mocking, and assertion frameworks used
+- **Harnesses**: Preexisting setups, base classes, or testing utilities
+- **Guidelines**: Testing or coding guidelines in instruction files, README, or docs
+
+If you identify a strong pattern, follow it unless the user explicitly requests otherwise. If no pattern exists and there's no user guidance, use your best judgment.
+
+## Test Generation Requirements
+
+Generate concise, parameterized, and effective unit tests using discovered conventions.
+
+- **Prefer mocking** over generating one-off testing types
+- **Prefer unit tests** over integration tests, unless integration tests are clearly needed and can run locally
+- **Traverse code thoroughly** to ensure high coverage (80%+) of the entire scope
+
+### Key Testing Goals
+
+| Goal                          | Description                                                                                          |
+| ----------------------------- | ---------------------------------------------------------------------------------------------------- |
+| **Minimal but Comprehensive** | Avoid redundant tests                                                                                |
+| **Logical Coverage**          | Focus on meaningful edge cases, domain-specific inputs, boundary values, and bug-revealing scenarios |
+| **Core Logic Focus**          | Test positive cases and actual execution logic; avoid low-value tests for language features          |
+| **Balanced Coverage**         | Don't let negative/edge cases outnumber tests of actual logic                                        |
+| **Best Practices**            | Use Arrange-Act-Assert pattern and proper naming (`Method_Condition_ExpectedResult`)                 |
+| **Buildable & Complete**      | Tests must compile, run, and contain no hallucinated or missed logic                                 |
+
+## Parameterization
+
+- Prefer parameterized tests (e.g., `[DataRow]`, `[Theory]`, `@pytest.mark.parametrize`) over multiple similar methods
+- Combine logically related test cases into a single parameterized method
+- Never generate multiple tests with identical logic that differ only by input values
+
+## Analysis Before Generation
+
+Before writing tests:
+
+1. **Analyze** the code line by line to understand what each section does
+2. **Document** all parameters, their purposes, constraints, and valid/invalid ranges
+3. **Identify** potential edge cases and error conditions
+4. **Describe** expected behavior under different input conditions
+5. **Note** dependencies that need mocking
+6. **Consider** concurrency, resource management, or special conditions
+7. **Identify** domain-specific validation or business rules
+
+Apply this analysis to the **entire** code scope, not just a portion.
+
+## Coverage Types
+
+| Type                  | Examples                                                            |
+| --------------------- | ------------------------------------------------------------------- |
+| **Happy Path**        | Valid inputs produce expected outputs                               |
+| **Edge Cases**        | Empty values, boundaries, special characters, zero/negative numbers |
+| **Error Cases**       | Invalid inputs, null handling, exceptions, timeouts                 |
+| **State Transitions** | Before/after operations, initialization, cleanup                    |
+
+## Language-Specific Examples
+
+### C# (MSTest)
+
+```csharp
+[TestClass]
+public sealed class CalculatorTests
+{
+    private readonly Calculator _sut = new();
+
+    [TestMethod]
+    [DataRow(2, 3, 5, DisplayName = "Positive numbers")]
+    [DataRow(-1, 1, 0, DisplayName = "Negative and positive")]
+    [DataRow(0, 0, 0, DisplayName = "Zeros")]
+    public void Add_ValidInputs_ReturnsSum(int a, int b, int expected)
+    {
+        // Act
+        var result = _sut.Add(a, b);
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void Divide_ByZero_ThrowsDivideByZeroException()
+    {
+        // Act & Assert
+        Assert.ThrowsException<DivideByZeroException>(() => _sut.Divide(10, 0));
+    }
+}
+```
+
+### TypeScript (Jest)
+
+```typescript
+describe("Calculator", () => {
+  let sut: Calculator;
+
+  beforeEach(() => {
+    sut = new Calculator();
+  });
+
+  it.each([
+    [2, 3, 5],
+    [-1, 1, 0],
+    [0, 0, 0],
+  ])("add(%i, %i) returns %i", (a, b, expected) => {
+    expect(sut.add(a, b)).toBe(expected);
+  });
+
+  it("divide by zero throws error", () => {
+    expect(() => sut.divide(10, 0)).toThrow("Division by zero");
+  });
+});
+```
+
+### Python (pytest)
+
+```python
+import pytest
+from calculator import Calculator
+
+class TestCalculator:
+    @pytest.fixture
+    def sut(self):
+        return Calculator()
+
+    @pytest.mark.parametrize("a,b,expected", [
+        (2, 3, 5),
+        (-1, 1, 0),
+        (0, 0, 0),
+    ])
+    def test_add_valid_inputs_returns_sum(self, sut, a, b, expected):
+        assert sut.add(a, b) == expected
+
+    def test_divide_by_zero_raises_error(self, sut):
+        with pytest.raises(ZeroDivisionError):
+            sut.divide(10, 0)
+```
+
+## Output Requirements
+
+- Tests must be **complete and buildable** with no placeholder code
+- Follow the **exact conventions** discovered in the target codebase
+- Include **appropriate imports** and setup code
+- Add **brief comments** explaining non-obvious test purposes
+- Place tests in the **correct location** following project structure

package/.github/skills/prompt-builder/SKILL.md

@@ -0,0 +1,159 @@
+---
+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/.github/workflows/npm-publish.yml

@@ -0,0 +1,25 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,111 @@
+# AI Workflow Template
+
+Publishable AI workflow starter pack for GitHub Copilot. This package distributes the `.github/` experience, auto-bumps versions through Husky, and publishes to npm on merges to `main`.
+
+## What This Package Does
+
+This repository is designed to be installed as an npm package instead of cloned as a one-off template. When a consuming project installs it, the package can copy its `.github/` folder into the consumer project and keep that folder in sync over time.
+
+### Included capabilities
+
+- Copilot instructions and workspace guidance in `.github/co-pilot.instructions.md`
+- Reusable skills in `.github/skills/`
+- Prompt templates in `.github/prompts/`
+- Custom agents in `.github/agents/`
+- Language and framework instructions in `.github/instructions/`
+- Version auto-bumping via Husky pre-commit hook
+- npm publishing workflow on merge to `main`
+
+## Install
+
+Install the package in the project that should receive the shared Copilot configuration.
+
+```bash
+npm install ai-workflow-template
+```
+
+If you publish under a scoped name, use that name instead.
+
+## Sync Behavior
+
+The package runs `scripts/sync.js` during `postinstall`.
+
+- New `.github` files are copied into the consumer project
+- Files that have not been edited locally are refreshed from the package
+- Files that were modified locally are skipped by default
+
+### Manual sync
+
+Use the sync script directly when you want to refresh the consumer project on demand.
+
+```bash
+npm run sync
+```
+
+Force overwrite of tracked files when you want the package version to win.
+
+```bash
+npm run sync -- --force
+```
+
+Preview the sync without writing files.
+
+```bash
+npm run sync -- --dry-run
+```
+
+## Versioning
+
+Husky runs a pre-commit hook that bumps the package version automatically.
+
+- Normal commits increment the minor version and reset patch to `0`
+- If the major version changes, the script resets the version to `<major>.0.0`
+
+Example:
+
+```text
+1.2.0 -> 1.3.0
+2.0.0 -> 2.1.0 on the next commit
+```
+
+## Publish Flow
+
+GitHub Actions publishes the package to npm when changes are merged into `main`.
+
+### Required secret
+
+Add `NPM_TOKEN` in GitHub repository settings:
+
+1. Open your repository on GitHub
+2. Go to Settings
+3. Open Secrets and variables, then Actions
+4. Add a new repository secret named `NPM_TOKEN`
+5. Paste an npm automation token
+
+## Local Development
+
+Install dependencies once to activate Husky hooks.
+
+```bash
+npm install
+```
+
+Recommended checks:
+
+```bash
+npm run sync -- --dry-run
+npm pack --json
+```
+
+## Updating the Shared Template
+
+1. Edit the files in `.github/` that should be distributed to consumer projects
+2. Commit your changes
+3. Merge to `main` to publish the updated package
+4. Consumers can run `npm install` again to pull the latest distributed files
+
+## Notes
+
+- The sync script uses `INIT_CWD` so installation runs against the consuming project, not the package directory
+- Local changes in a consuming repo are preserved unless you explicitly use `--force`
+- The publish workflow assumes the package is public on npm

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@abarcenas/ai-workflow-template",
+  "version": "1.1.0",
+  "description": "A comprehensive template repository for AI-assisted development workflows using GitHub Copilot. This template provides a structured approach to leveraging AI assistance through pre-configured skills, prompts, agents, and coding standards.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "husky",
+    "sync": "node ./scripts/sync.js",
+    "postinstall": "node ./scripts/sync.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abarcenas29/ai-workflow-template.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/abarcenas29/ai-workflow-template/issues"
+  },
+  "homepage": "https://github.com/abarcenas29/ai-workflow-template#readme",
+  "files": [
+    ".github/",
+    "scripts/"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "husky": "^9.0.0"
+  }
+}

package/scripts/bump-version.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync } from 'fs'
+import { execSync } from 'child_process'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const pkgPath = resolve(__dirname, '../package.json')
+
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+const current = pkg.version
+const [curMajor, curMinor] = current.split('.').map(Number)
+
+let prevMajor = curMajor
+try {
+  const prevPkg = JSON.parse(execSync('git show HEAD:package.json', { encoding: 'utf8' }))
+  prevMajor = Number(prevPkg.version.split('.')[0])
+} catch {
+  // First commit — no HEAD yet, keep prevMajor === curMajor so minor bumps normally
+}
+
+const newVersion =
+  curMajor !== prevMajor
+    ? `${curMajor}.0.0`                    // Major changed: normalize, reset minor + patch
+    : `${curMajor}.${curMinor + 1}.0`      // Normal commit: bump minor, reset patch
+
+pkg.version = newVersion
+writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+execSync('git add package.json')
+console.log(`Version bumped: ${current} → ${newVersion}`)

package/scripts/sync.js

@@ -0,0 +1,122 @@
+import { createHash } from 'crypto'
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'fs'
+import { dirname, join, relative, resolve } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packageRoot = resolve(__dirname, '..')
+const sourceGithubDir = resolve(packageRoot, '.github')
+const consumerRoot = process.env.INIT_CWD ? resolve(process.env.INIT_CWD) : process.cwd()
+const targetGithubDir = resolve(consumerRoot, '.github')
+const manifestPath = resolve(consumerRoot, '.github-sync-manifest.json')
+const args = new Set(process.argv.slice(2))
+const forceOverwrite = args.has('--force')
+const dryRun = args.has('--dry-run')
+
+function hashFile(filePath) {
+  const contents = readFileSync(filePath)
+  return createHash('sha256').update(contents).digest('hex')
+}
+
+function collectFiles(directory) {
+  const entries = readdirSync(directory, { withFileTypes: true })
+  const files = []
+
+  for (const entry of entries) {
+    const entryPath = join(directory, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(entryPath))
+      continue
+    }
+
+    if (entry.isFile()) {
+      files.push(entryPath)
+    }
+  }
+
+  return files
+}
+
+function readManifest() {
+  if (!existsSync(manifestPath)) {
+    return { version: 1, files: {} }
+  }
+
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+    if (!manifest || typeof manifest !== 'object') {
+      return { version: 1, files: {} }
+    }
+
+    if (!manifest.files || typeof manifest.files !== 'object') {
+      manifest.files = {}
+    }
+
+    return manifest
+  } catch {
+    return { version: 1, files: {} }
+  }
+}
+
+function writeManifest(manifest) {
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+}
+
+function ensureParentDirectory(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true })
+}
+
+function syncFile(sourceFile, targetFile) {
+  if (dryRun) {
+    return
+  }
+
+  ensureParentDirectory(targetFile)
+  copyFileSync(sourceFile, targetFile)
+}
+
+if (!existsSync(sourceGithubDir)) {
+  console.warn('[ai-workflow-template] No .github directory found to sync.')
+  process.exit(0)
+}
+
+const manifest = readManifest()
+const sourceFiles = collectFiles(sourceGithubDir)
+let copied = 0
+let skipped = 0
+let added = 0
+
+for (const sourceFile of sourceFiles) {
+  const relativePath = relative(sourceGithubDir, sourceFile)
+  const targetFile = resolve(targetGithubDir, relativePath)
+  const sourceHash = hashFile(sourceFile)
+  const existingHash = existsSync(targetFile) ? hashFile(targetFile) : null
+  const recordedHash = manifest.files[relativePath] ?? null
+
+  if (!existsSync(targetFile)) {
+    syncFile(sourceFile, targetFile)
+    manifest.files[relativePath] = sourceHash
+    copied += 1
+    added += 1
+    continue
+  }
+
+  const isUntouched = recordedHash !== null && existingHash === recordedHash
+
+  if (forceOverwrite || isUntouched) {
+    syncFile(sourceFile, targetFile)
+    manifest.files[relativePath] = sourceHash
+    copied += 1
+    continue
+  }
+
+  skipped += 1
+  console.warn(`[ai-workflow-template] Skipped locally modified file: ${relativePath}`)
+}
+
+if (!dryRun) {
+  writeManifest(manifest)
+}
+
+const modeLabel = forceOverwrite ? 'force' : dryRun ? 'dry-run' : 'safe'
+console.log(`[ai-workflow-template] Synced ${copied} files (${added} new), skipped ${skipped} modified files. Mode: ${modeLabel}.`)