symfonia-ai-tools 1.0.0

package/templates/base/_ai/skills/jira-task/SKILL.md

@@ -0,0 +1,170 @@
+# Skill: Jira Task — Full Development Workflow
+
+## Trigger
+Use when given a Jira ticket number to implement, when asked to work on a task/feature/bugfix from Jira, or when user says to pick up a ticket.
+
+## Overview
+
+Automates the complete dev cycle: Jira ticket → analysis → branch → implementation → code review → PR → Jira updates. Requires Jira MCP server. Detects hosting platform (GitHub or Bitbucket) from `git remote`.
+
+## Step-by-Step
+
+### 1. Fetch Jira Ticket
+
+Fetch ticket details and images in parallel:
+```
+mcp__mcp-atlassian__jira_get_issue(issue_key: "{{JIRA_PREFIX}}-XXXXX", comment_limit: 50)
+mcp__mcp-atlassian__jira_get_issue_images(issue_key: "{{JIRA_PREFIX}}-XXXXX")
+```
+
+Extract: summary, description, status, assignee, linked issues, comments.
+
+**Images** — analyze carefully, they often contain the actual requirements, mockups, or error screenshots not present in the text.
+
+**Comments** — read all comments, they often contain additional context, decisions, and clarifications.
+
+**Assignee check** — if someone else is already assigned, ask the user before taking over.
+
+### 2. Analyze Requirements
+
+Read the ticket text, images, AND comments thoroughly.
+
+**Check linked issues and parent epic** for additional context:
+```
+mcp__mcp-atlassian__jira_get_issue(issue_key: "{PARENT-OR-LINKED-KEY}")
+```
+
+Ask the user if anything is unclear — don't assume.
+
+### 3. Create Branch
+
+```bash
+git fetch origin {{BASE_BRANCH}}
+git checkout -b {prefix}/{{JIRA_PREFIX}}-{ticket-number}-{short-description} origin/{{BASE_BRANCH}}
+```
+
+**Branch prefix** based on ticket type:
+- Bug → `bugfix/`
+- Feature/Story → `feature/`
+- Hotfix → `hotfix/`
+
+If multiple base branches exist, ask the user which one to use.
+
+**Transition ticket to Work in Progress:**
+```
+mcp__mcp-atlassian__jira_get_transitions(issue_key: "{{JIRA_PREFIX}}-XXXXX")
+```
+Walk through transitions until WIP. Also assign to yourself if not already assigned.
+
+### 4. Explore Codebase
+
+Use the `Explore` subagent or Glob/Grep to understand the relevant module, existing patterns, and conventions.
+
+**Read project guidelines** — before writing any code, read `.ai/guidelines.md` for coding standards and conventions. Also check `.ai/skills/` for module-specific skills that may apply to your task.
+
+### 5. Implement
+
+- **Follow `.ai/guidelines.md`** strictly
+- Follow existing codebase patterns
+- Add tests (mirror existing test structure)
+- Add documentation if applicable
+
+**Commit format** (from `commit-instructions.md`):
+```
+{{JIRA_PREFIX}}-{number}: description of change
+```
+
+### 6. Code Review
+
+Before pushing, run a self-review of all changes (`git diff origin/{{BASE_BRANCH}}...HEAD`). Check for:
+
+1. **Security** — SQL injection, XSS, command injection, mass assignment, IDOR, sensitive data exposure
+2. **Code quality** — dead code, duplication, naming, missing validation at system boundaries
+3. **Logic** — edge cases, off-by-one errors, null handling, race conditions
+4. **Tests** — adequate coverage, missing negative cases, brittle assertions
+
+Fix all critical and important issues found before proceeding.
+
+**Run tests** before pushing:
+```bash
+{{TEST_COMMAND}}
+```
+
+### 7. Push + Create PR
+
+**Rebase on latest base branch:**
+```bash
+git fetch origin {{BASE_BRANCH}}
+git rebase origin/{{BASE_BRANCH}}
+```
+
+If conflicts arise, resolve them before pushing.
+
+```bash
+git push -u origin {branch-name}
+```
+
+**Create PR** — detect platform from `git remote`:
+
+#### GitHub
+```bash
+gh pr create --title "{{JIRA_PREFIX}}-{number}: {description}" --body "## Summary\n- ...\n\n## Test plan\n- [ ] ..." --base {{BASE_BRANCH}}
+```
+
+#### Bitbucket
+```
+mcp__mcp-bitbucket__bb_post(
+  path: "/repositories/{OWNER}/{REPO}/pullrequests",
+  body: {
+    "title": "{{JIRA_PREFIX}}-{number}: {description}",
+    "source": {"branch": {"name": "{branch}"}},
+    "destination": {"branch": {"name": "{{BASE_BRANCH}}"}},
+    "description": "## Summary\n- ...\n\n## Test plan\n- [ ] ...",
+    "close_source_branch": true
+  }
+)
+```
+
+### 8. Update Jira
+
+Do ALL of these in parallel:
+
+**a) Add comment** with branch + PR link + what was done:
+```
+mcp__mcp-atlassian__jira_add_comment(issue_key, body: "Branch: `{branch}`\nPR: {url}\n\n**What was done:**\n- ...")
+```
+
+**b) Log worklog** (ask user for hours if not specified):
+```
+mcp__mcp-atlassian__jira_add_worklog(issue_key, time_spent: "2h", comment: "...")
+```
+
+**c) Transition status to IN REVIEW:**
+```
+mcp__mcp-atlassian__jira_get_transitions(issue_key: "{{JIRA_PREFIX}}-XXXXX")
+```
+Walk through transitions step by step until review status. Always call `jira_get_transitions` first — IDs vary per project.
+
+### 9. After PR is Merged
+
+When the branch is merged (user confirms or PR state = MERGED):
+
+1. **Transition to Ready for test** (or equivalent — check available transitions)
+2. **Set fix version** if user specifies one
+3. **Assign to tester** if applicable
+
+### 10. Monitor PR (optional)
+
+After creating the PR, ask the user if they want a monitoring loop. If yes, set up a 5-minute loop that checks PR state and auto-finishes Step 9 when merged.
+
+## Common Mistakes
+
+| Mistake | Fix |
+|---------|-----|
+| Forgetting to fetch base branch before branching | Always `git fetch origin {{BASE_BRANCH}}` first |
+| Assuming base branch without asking | Ask user if multiple candidates exist |
+| Pushing before code review | Always self-review (including security) first |
+| Not walking through Jira transitions step by step | Can't jump statuses — must transition sequentially |
+| Not reading `.ai/guidelines.md` before coding | Coding standards apply — read once per task |
+| Not running tests before pushing | Run test suite — don't push failing code |
+| Not rebasing before push | Base branch may have moved — rebase to avoid merge conflicts |

package/templates/base/_ai/skills/my-prs/SKILL.md

@@ -0,0 +1,78 @@
+# Skill: My PRs
+
+## Trigger
+Use when user wants to check status of their own open PRs, see how many approvals are missing, or check for new reviewer comments.
+
+## Overview
+
+Check the status of your own open pull requests — approvals, missing approvals, and new comments. Detects platform (GitHub or Bitbucket) from `git remote`.
+
+## Step 1: Detect User and Repo
+
+```bash
+git config user.name
+git remote get-url origin
+```
+
+Parse origin URL to determine `{PLATFORM}`, `{OWNER}`, `{REPO}`, `{USER_NAME}`.
+Store `{WEEK_AGO}` as date 7 days ago (YYYY-MM-DD).
+
+## Step 2: Fetch Your Open PRs
+
+### GitHub
+
+```bash
+gh pr list --repo {OWNER}/{REPO} --author "@me" --state open --json number,title,headRefName,url,createdAt,reviews,comments
+```
+
+### Bitbucket
+
+```
+mcp__mcp-bitbucket__bb_get
+path: /repositories/{OWNER}/{REPO}/pullrequests
+queryParams: {"pagelen": "50", "q": "state=\"OPEN\" AND updated_on >= {WEEK_AGO}"}
+```
+
+Filter to only PRs where author matches `{USER_NAME}`.
+
+## Step 3: For Each PR, Fetch Details
+
+### GitHub
+
+```bash
+gh pr view {number} --repo {OWNER}/{REPO} --json reviews,comments,reviewRequests
+```
+
+- Count reviews where `state == "APPROVED"`
+- List who approved
+- Count comments from others
+
+### Bitbucket
+
+Fetch participants:
+```
+mcp__mcp-bitbucket__bb_get
+path: /repositories/{OWNER}/{REPO}/pullrequests/{id}
+```
+
+Fetch comments:
+```
+mcp__mcp-bitbucket__bb_get
+path: /repositories/{OWNER}/{REPO}/pullrequests/{id}/comments
+queryParams: {"pagelen": "50", "sort": "-created_on"}
+```
+
+Filter out your own comments. Flag unresolved ones.
+
+## Step 4: Present Results
+
+| PR | Title | Approvals | Missing | Comments | Link |
+|----|-------|-----------|---------|----------|------|
+| **#1234** | Short title | 2/3 (Alice, Bob) | 1 more needed | 3 new comments | [Open PR](url) |
+
+- **Approvals**: `{count}/{required}` + who approved
+- **Missing**: how many more approvals needed, or "Ready to merge!" if enough
+- **Comments**: count of comments from others, highlight if there are unresolved/recent ones
+- **Link**: direct URL to PR
+
+If no open PRs: "No open PRs found."

package/templates/base/_ai/skills/pr-dashboard/SKILL.md

@@ -0,0 +1,43 @@
+# Skill: PR Dashboard
+
+## Trigger
+Use when user wants a full PR dashboard — monitors both incoming PRs waiting for review and tracks own PRs approval status, optionally sets up recurring checks.
+
+## Overview
+
+Combined PR monitoring. Runs both incoming PR check and own PR status check. Can optionally set up a 10-minute polling loop.
+
+## Setup
+
+1. Detect user and repo:
+   ```bash
+   git config user.name
+   git remote get-url origin
+   ```
+   Parse platform, owner, repo, user name.
+
+2. Ask user: "Set up a recurring 10-minute check?" If yes, use CronCreate with `*/10 * * * *`.
+
+3. Run first check immediately.
+
+## How to Check
+
+### Section 1 — Incoming PRs
+
+Follow the `babysit-prs` skill steps (skip loop setup). Show the incoming PRs table.
+
+### Section 2 — My PRs
+
+Follow the `my-prs` skill steps. Show the my PRs table.
+
+### Combined Output Format
+
+```
+## PR Dashboard
+
+### Incoming PRs to review
+(table from babysit-prs or "No new PRs to review.")
+
+### My PRs
+(table from my-prs or "No open PRs found.")
+```

package/templates/base/_ai/skills/pr-prepare/SKILL.md

@@ -0,0 +1,106 @@
+# Skill: Prepare Pull Request
+
+## Trigger
+Use before pushing code and creating a pull request.
+
+## Input
+- Branch name
+- Related ticket/issue (if any)
+- Target branch (default: develop)
+
+## Steps
+
+### 1. Self-review diff
+
+```bash
+git diff {{BASE_BRANCH}}...HEAD --stat
+git diff {{BASE_BRANCH}}...HEAD
+```
+
+Check every changed file:
+- [ ] No debug code (console.log, dd(), var_dump, debugger)
+- [ ] No commented-out code
+- [ ] No TODO/FIXME without ticket reference
+- [ ] No hardcoded values that should be config
+- [ ] No secrets or credentials
+- [ ] No unrelated changes (scope creep)
+
+### 2. Verify tests pass
+
+```bash
+{{TEST_COMMAND}}
+{{LINT_COMMAND}}
+{{BUILD_COMMAND}}
+```
+
+All three must pass. Fix issues before proceeding.
+
+### 3. Check commit history
+
+```bash
+git log {{BASE_BRANCH}}...HEAD --oneline
+```
+
+Evaluate:
+- Are commits atomic (one logical change each)?
+- Do commit messages follow Conventional Commits?
+- Are there WIP/fixup commits that should be squashed?
+
+If cleanup needed:
+```bash
+git rebase -i {{BASE_BRANCH}}
+```
+
+### 4. Write PR description
+
+Structure:
+
+```markdown
+## What
+[One sentence: what this PR does]
+
+## Why
+[Context: ticket link, problem description]
+
+## How
+[Key technical decisions, approach taken]
+
+## Testing
+[How to test: steps, commands, screenshots]
+
+## Checklist
+- [ ] Tests added/updated
+- [ ] Linter passes
+- [ ] Build passes
+- [ ] Documentation updated (if needed)
+- [ ] Breaking changes noted (if any)
+```
+
+### 5. Final review
+
+Before pushing, verify:
+- [ ] PR has a clear, descriptive title (Conventional Commits format)
+- [ ] Description explains what AND why
+- [ ] No files accidentally included (check .gitignore)
+- [ ] Branch is up to date with target branch
+- [ ] All CI checks will pass
+
+```bash
+# Rebase on latest target
+git fetch origin
+git rebase origin/{{BASE_BRANCH}}
+
+# Final test after rebase
+{{TEST_COMMAND}}
+```
+
+### 6. Verification checklist
+
+- [ ] No debug/temp code in diff
+- [ ] No unrelated changes
+- [ ] Tests pass
+- [ ] Lint passes
+- [ ] Build passes
+- [ ] Commits are clean and atomic
+- [ ] PR description is complete
+- [ ] Branch is rebased on latest target

package/templates/base/_ai/skills/refactor/SKILL.md

@@ -0,0 +1,87 @@
+# Skill: Systematic Refactoring
+
+## Trigger
+Use when refactoring code - extracting, restructuring, or simplifying without changing behavior.
+
+## Input
+- Target file(s) or module
+- Goal (extract, simplify, split, rename, etc.)
+- Constraints (backward compatibility, etc.)
+
+## Steps
+
+### 1. Understand current code
+
+- Read all files involved
+- Identify public API (what other code depends on)
+- List all callers/imports of the code being refactored
+- Run existing tests to confirm green baseline
+
+```bash
+# Run tests before ANY changes
+{{TEST_COMMAND}}
+```
+
+### 2. Plan refactoring
+
+Document:
+- **What** changes (file, function, class)
+- **Why** (duplication, complexity, readability, single responsibility)
+- **Impact** - list files that import/use the target code
+- **Risk** - what could break
+
+### 3. Make smallest possible change
+
+One refactoring at a time. Do NOT combine multiple refactorings in one step.
+
+Order of operations:
+1. Extract → test
+2. Rename → test
+3. Move → test
+4. Simplify → test
+
+### 4. Test after each change
+
+```bash
+{{TEST_COMMAND}}
+```
+
+If tests fail → revert last change, understand why, try different approach.
+
+### 5. Update callers
+
+After renaming or moving:
+- Update all imports
+- Update all references
+- Search for string references (config, route names, etc.)
+
+### 6. Remove dead code
+
+After extraction/move:
+- Delete original code only AFTER all callers updated
+- Do not leave commented-out code
+- Do not leave unused imports
+
+### 7. Final verification
+
+```bash
+# Full test suite
+{{TEST_COMMAND}}
+
+# Lint
+{{LINT_COMMAND}}
+
+# Build (catch type errors)
+{{BUILD_COMMAND}}
+```
+
+### 8. Verification checklist
+
+- [ ] Tests pass before AND after refactoring
+- [ ] No behavioral changes (same inputs → same outputs)
+- [ ] All callers updated
+- [ ] No dead code left
+- [ ] No commented-out code
+- [ ] Lint passes
+- [ ] Build passes
+- [ ] Each commit is one atomic refactoring step

package/templates/base/_ai/skills/write-tests/SKILL.md

@@ -0,0 +1,109 @@
+# Skill: Write Tests for Existing Code
+
+## Trigger
+Use when adding tests to existing code that lacks test coverage.
+
+## Input
+- Target file(s) or module to test
+- Test framework already in use
+- Priority areas (critical paths, recent bugs, etc.)
+
+## Steps
+
+### 1. Analyze the code
+
+- Read all target files
+- Identify public API: exported functions, class methods, component props/events
+- List dependencies and side effects (API calls, DB, file system)
+- Note edge cases: nulls, empty arrays, boundary values, error states
+
+### 2. Categorize test types needed
+
+- **Unit tests** — pure functions, services, utilities, stores
+- **Integration tests** — components with dependencies, API calls, DB queries
+- **Feature/E2E tests** — full user flows through multiple layers
+
+Prioritize: unit > integration > e2e (more coverage per effort).
+
+### 3. List test cases
+
+For each function/method, write a test case list BEFORE writing code:
+
+```
+[function_name]
+  - returns expected output for valid input
+  - handles empty input
+  - handles null/undefined
+  - throws on invalid input
+  - edge case: [specific to function]
+```
+
+Review the list — are critical paths covered? Add missing cases.
+
+### 4. Set up test file
+
+```bash
+# Verify test framework works
+{{TEST_COMMAND}}
+```
+
+Create test file following project conventions:
+- Mirror source file path in test directory
+- Use existing test files as pattern reference
+- Set up shared fixtures/factories/mocks
+
+### 5. Write tests — simplest first
+
+Start with the easiest, most obvious test:
+- Valid input → expected output
+- No mocks needed
+- Confirms test setup works
+
+```bash
+# Run after first test to verify setup
+{{TEST_COMMAND}}
+```
+
+### 6. Add remaining tests incrementally
+
+For each test case from step 3:
+1. Write the test
+2. Run it
+3. Fix if red (test bug vs code bug — know the difference)
+
+Group related tests in `describe` blocks.
+
+### 7. Handle dependencies
+
+For code with external dependencies:
+- **API calls** → mock HTTP client / use test server
+- **Database** → use transactions / test DB / factories
+- **Time** → freeze time / inject clock
+- **File system** → temp directories / mock fs
+
+Mock at the boundary, not deep inside the code.
+
+### 8. Verify coverage
+
+```bash
+# Run with coverage
+{{TEST_COMMAND}} --coverage
+```
+
+Check:
+- All public methods have at least one test
+- Error paths are tested (not just happy path)
+- Edge cases from step 1 are covered
+
+### 9. Verification checklist
+
+- [ ] All public functions/methods have tests
+- [ ] Happy path tested
+- [ ] Error/edge cases tested
+- [ ] Mocks are minimal (boundary only)
+- [ ] Tests are independent (no shared mutable state)
+- [ ] Tests run fast (no unnecessary waits/timeouts)
+- [ ] Test names describe behavior, not implementation
+- [ ] No test depends on execution order
+- [ ] All tests pass
+- [ ] No production code was changed

package/templates/base/_claude/settings.local.json

@@ -0,0 +1,37 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx get-shit-done-cc@latest:*)",
+      "Bash(claude mcp:*)",
+      "Bash(npm search:*)",
+      "Bash(npm info:*)",
+      "Bash(npm run:*)",
+      "Bash(npm test:*)",
+      "Bash(npm install:*)",
+      "Bash(npx:*)",
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
+      "Bash(git branch:*)",
+      "Bash(git checkout:*)",
+      "Bash(git add:*)",
+      "Bash(git stash:*)",
+      "Bash(git fetch:*)",
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "Bash(find:*)",
+      "Bash(grep:*)",
+      "Bash(wc:*)",
+      "Bash(head:*)",
+      "Bash(tail:*)",
+      "Read(~/.claude/**)"
+    ],
+    "deny": [
+      "Bash(rm -rf:*)",
+      "Bash(git push --force:*)",
+      "Bash(git reset --hard:*)",
+      "Bash(DROP TABLE:*)",
+      "Bash(curl * | bash:*)"
+    ]
+  }
+}

package/templates/base/_cursor/rules/global.mdc

@@ -0,0 +1,7 @@
+---
+description: Global project rules
+globs:
+alwaysApply: true
+---
+
+Read and follow .ai/guidelines.md as mandatory context.

package/templates/base/_editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.{php,py,java}]
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

package/templates/base/_gemini/settings.json

@@ -0,0 +1,3 @@
+[
+  ".ai/guidelines.md"
+]

package/templates/base/_github/copilot-instructions.md

@@ -0,0 +1 @@
+Read and follow .ai/guidelines.md as mandatory context for all work in this project.

package/templates/base/_github/pull_request_template.md

@@ -0,0 +1,23 @@
+## Summary
+
+<!-- What does this PR do? Link to JIRA ticket. -->
+
+{{JIRA_PREFIX}}-XXXX
+
+## Changes
+
+-
+
+## Testing
+
+- [ ] Unit tests added/updated
+- [ ] Integration tests (if applicable)
+- [ ] Manual testing done
+
+## Checklist
+
+- [ ] Code follows project conventions (`.ai/guidelines.md`)
+- [ ] No `console.log` / debug code left
+- [ ] No hardcoded secrets or URLs
+- [ ] CI passes: `{{CI_COMMAND}}`
+- [ ] Self-reviewed the diff before requesting review