@hasna/assistants 1.1.97 → 1.1.98

package/dist/.assistants/skills/skill-codereview/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: codereview
+description: Review code for bugs, security issues, performance problems, and style. Accepts a file path, diff, or inline code snippet.
+argument-hint: [file-path-or-diff]
+allowed-tools: Read, Bash
+---
+
+## Code Review
+
+Review the following for: $ARGUMENTS
+
+### What to look for
+
+1. **Bugs & correctness** — logic errors, off-by-one, null/undefined handling, edge cases, incorrect assumptions
+2. **Security** — injection risks (SQL, shell, XSS), hardcoded secrets, insecure defaults, improper input validation, path traversal
+3. **Performance** — N+1 queries, unnecessary re-renders, blocking operations, missing indexes, large allocations
+4. **Readability** — unclear naming, overly complex logic that could be simplified, missing or misleading comments
+5. **Error handling** — swallowed errors, missing error boundaries, unclear error messages
+6. **Type safety** — `any` types, unsafe casts, missing nullability checks
+
+### Process
+
+1. If `$ARGUMENTS` is a file path, read the file first with the Read tool
+2. If it's a glob or directory, read the relevant files
+3. If it's inline code, review it directly
+4. For each issue found, state: **location** → **severity** (critical/high/medium/low) → **problem** → **fix**
+
+### Output format
+
+```
+## Code Review: <file or description>
+
+### Critical
+- [line X] <issue> → <fix>
+
+### High
+- [line X] <issue> → <fix>
+
+### Medium / Low
+- <issue> → <fix>
+
+### Summary
+<1-2 sentence overall assessment>
+```
+
+If no issues are found, say so explicitly — don't pad with non-issues.

package/dist/.assistants/skills/skill-commitmsg/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: commitmsg
+description: Generate a conventional commit message from staged changes or a diff. Follows Conventional Commits spec (feat/fix/chore/refactor/docs/test/perf/ci).
+argument-hint: [optional: file paths or description]
+allowed-tools: Bash
+---
+
+## Generate Commit Message
+
+$ARGUMENTS
+
+### Process
+
+1. Run `git diff --staged` to see staged changes (or `git diff HEAD` if nothing staged)
+2. If `$ARGUMENTS` mentions specific files, focus on those
+3. Analyse what changed — what was added, removed, modified, and why
+4. Generate a commit message following Conventional Commits
+
+### Conventional Commits format
+
+```
+<type>(<scope>): <short summary>
+
+<optional body: what changed and why, wrapped at 72 chars>
+
+<optional footer: BREAKING CHANGE: ..., Closes #123>
+```
+
+**Types:** `feat` (new feature), `fix` (bug fix), `perf` (performance), `refactor` (no behaviour change), `docs` (documentation only), `test` (tests only), `chore` (tooling/deps), `ci` (CI/CD), `style` (formatting)
+
+**Rules:**
+- Subject line ≤ 72 characters, imperative mood ("add X" not "added X")
+- Scope is optional but useful (e.g. `feat(auth):`, `fix(cli):`)
+- Body explains *why*, not *what* (the diff shows what)
+- Mark breaking changes with `BREAKING CHANGE:` in footer
+- Reference issues with `Closes #N` or `Fixes #N`
+
+### Output
+
+Print the ready-to-use commit message in a code block so it can be copied directly.
+If the changes span multiple unrelated concerns, suggest splitting into separate commits.

package/dist/.assistants/skills/skill-debug/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: debug
+description: Structured debugging session. Accepts an error message, stack trace, or description of unexpected behaviour. Works through reproduce → isolate → hypothesize → verify → fix.
+argument-hint: [error message or description]
+allowed-tools: Bash, Read, Grep
+---
+
+## Debug Session
+
+**Problem:** $ARGUMENTS
+
+### Step 1 — Understand the error
+
+- Parse the error message and stack trace
+- Identify the failing file, line, and function
+- Note what was expected vs. what actually happened
+
+### Step 2 — Reproduce
+
+- Find the minimal steps or input that trigger the issue
+- Run the failing command / test to confirm the error is present
+- Note exact error output
+
+### Step 3 — Isolate
+
+- Narrow down to the smallest code path involved
+- Check recent changes (`git log --oneline -10`, `git diff HEAD~1`) — did something recently break this?
+- Search for related error messages or similar patterns in the codebase
+
+### Step 4 — Hypothesize
+
+- List 2–3 plausible root causes, ranked by likelihood
+- For each hypothesis, state what evidence would confirm or rule it out
+
+### Step 5 — Verify
+
+- Test each hypothesis by reading relevant code, adding debug output, or running targeted commands
+- Eliminate hypotheses one by one until the root cause is confirmed
+
+### Step 6 — Fix
+
+- Implement the minimal correct fix
+- Verify the fix resolves the original error
+- Check for related issues the fix might cause
+- Add a regression note if useful
+
+### Output format
+
+Work through each step out loud. Show commands run and their output. End with:
+```
+## Root cause
+<one sentence>
+
+## Fix applied
+<what was changed>
+
+## Verified by
+<how you confirmed it works>
+```