@mohammadhprp/system-prompt 0.12.4 → 0.12.6

package/framework/skills/review/scripts/validate_review_json.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""Validate a review.json artifact against an annotated PR diff.
+
+This script is packaged with the review-pr skill and must work when the skill
+is copied into a consuming repository without the full oz-for-oss source tree.
+Keep it self-contained: do not import helpers from the repository package.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypedDict
+
+
+class ReviewComment(TypedDict, total=False):
+    """Normalized review comment accepted by GitHub's create-review API."""
+
+    path: str
+    line: int
+    side: str
+    body: str
+    start_line: int
+    start_side: str
+
+
+@dataclass(frozen=True)
+class ReviewValidationResult:
+    """Validated review fields plus any comment-location errors."""
+
+    body: str
+    comments: list[ReviewComment]
+    errors: list[str]
+
+
+SUGGESTION_BLOCK_PATTERN = re.compile(
+    r"```suggestion[^\n]*\r?\n(?P<content>.*?)\r?\n```",
+    re.DOTALL,
+)
+ANNOTATED_OLD_PATTERN = re.compile(r"^\[OLD:(?P<old>\d+)\] ?(?P<text>.*)$")
+ANNOTATED_NEW_PATTERN = re.compile(r"^\[NEW:(?P<new>\d+)\] ?(?P<text>.*)$")
+ANNOTATED_CONTEXT_PATTERN = re.compile(
+    r"^\[OLD:(?P<old>\d+),NEW:(?P<new>\d+)\] ?(?P<text>.*)$"
+)
+
+
+def normalize_review_path(value: Any) -> str:
+    path = str(value or "").strip()
+    path = re.sub(r"^(a/|b/|\./)", "", path)
+    return path
+
+
+def build_diff_maps_from_annotated_diff(
+    diff_text: str,
+) -> tuple[dict[str, dict[str, set[int]]], dict[str, dict[str, dict[int, str]]]]:
+    """Build validation maps from the annotated diff shown to review agents."""
+    diff_line_map: dict[str, dict[str, set[int]]] = {}
+    diff_content_map: dict[str, dict[str, dict[int, str]]] = {}
+    current_path = ""
+    old_path = ""
+
+    def ensure_path(path: str) -> None:
+        diff_line_map.setdefault(path, {"LEFT": set(), "RIGHT": set()})
+        diff_content_map.setdefault(path, {"LEFT": {}, "RIGHT": {}})
+
+    for raw_line in diff_text.splitlines():
+        if raw_line.startswith("diff --git "):
+            current_path = ""
+            old_path = ""
+            continue
+        if raw_line.startswith("--- "):
+            candidate = raw_line[4:].strip()
+            old_path = (
+                "" if candidate == "/dev/null" else normalize_review_path(candidate)
+            )
+            continue
+        if raw_line.startswith("+++ "):
+            candidate = raw_line[4:].strip()
+            if candidate == "/dev/null":
+                current_path = old_path
+            else:
+                current_path = normalize_review_path(candidate)
+            if current_path:
+                ensure_path(current_path)
+            continue
+        if not current_path:
+            continue
+        old_match = ANNOTATED_OLD_PATTERN.match(raw_line)
+        if old_match:
+            line = int(old_match.group("old"))
+            text = old_match.group("text")
+            diff_line_map[current_path]["LEFT"].add(line)
+            diff_content_map[current_path]["LEFT"][line] = text
+            continue
+        new_match = ANNOTATED_NEW_PATTERN.match(raw_line)
+        if new_match:
+            line = int(new_match.group("new"))
+            text = new_match.group("text")
+            diff_line_map[current_path]["RIGHT"].add(line)
+            diff_content_map[current_path]["RIGHT"][line] = text
+            continue
+        context_match = ANNOTATED_CONTEXT_PATTERN.match(raw_line)
+        if context_match:
+            old_line = int(context_match.group("old"))
+            new_line = int(context_match.group("new"))
+            text = context_match.group("text")
+            diff_line_map[current_path]["LEFT"].add(old_line)
+            diff_line_map[current_path]["RIGHT"].add(new_line)
+            diff_content_map[current_path]["LEFT"][old_line] = text
+            diff_content_map[current_path]["RIGHT"][new_line] = text
+
+    return diff_line_map, diff_content_map
+
+
+def _extract_suggestion_blocks(body: str | None) -> list[list[str]]:
+    blocks: list[list[str]] = []
+    for match in SUGGESTION_BLOCK_PATTERN.finditer(body or ""):
+        content = match.group("content")
+        lines = [line.rstrip("\r") for line in content.split("\n")]
+        blocks.append(lines)
+    return blocks
+
+
+def _validate_suggestion_blocks(
+    comment: dict[str, Any],
+    diff_content_map: dict[str, dict[str, dict[int, str]]],
+) -> list[str]:
+    errors: list[str] = []
+    body = comment.get("body") or ""
+    blocks = _extract_suggestion_blocks(body)
+    if not blocks:
+        return errors
+
+    path = comment.get("path") or ""
+    side = comment.get("side") or "RIGHT"
+    start_side = comment.get("start_side") or side
+    line_no = comment.get("line")
+    if not isinstance(line_no, int):
+        return errors
+    start_line = comment.get("start_line") or line_no
+    content_for_start_side = diff_content_map.get(path, {}).get(start_side, {})
+    content_for_end_side = diff_content_map.get(path, {}).get(side, {})
+
+    for block_index, block_lines in enumerate(blocks):
+        if not block_lines or block_lines == [""]:
+            continue
+        prev_context = content_for_start_side.get(start_line - 1)
+        next_context = content_for_end_side.get(line_no + 1)
+        first_line = block_lines[0]
+        last_line = block_lines[-1]
+        if prev_context is not None and first_line == prev_context:
+            errors.append(
+                f"suggestion block {block_index} duplicates the context line immediately above "
+                f"`start_line` ({start_line - 1}); that line is not replaced and will appear twice after the suggestion is applied"
+            )
+        if next_context is not None and last_line == next_context:
+            errors.append(
+                f"suggestion block {block_index} duplicates the context line immediately below "
+                f"`line` ({line_no + 1}); that line is not replaced and will appear twice after the suggestion is applied"
+            )
+    return errors
+
+
+def validate_review_payload(
+    review: Any,
+    diff_line_map: dict[str, dict[str, set[int]]],
+    diff_content_map: dict[str, dict[str, dict[int, str]]] | None = None,
+) -> ReviewValidationResult:
+    """Validate a review.json payload against the annotated PR diff."""
+    if not isinstance(review, dict):
+        raise ValueError("Review payload must be a JSON object.")
+
+    raw_body = review.get("body")
+    if raw_body is None:
+        raw_body = review.get("summary") or ""
+    if not isinstance(raw_body, str):
+        raise ValueError("Review payload `body` must be a string.")
+
+    raw_comments = review.get("comments") or []
+    if not isinstance(raw_comments, list):
+        raise ValueError("Review payload `comments` must be a list.")
+
+    normalized_comments: list[ReviewComment] = []
+    errors: list[str] = []
+
+    for index, raw_comment in enumerate(raw_comments):
+        if not isinstance(raw_comment, dict):
+            errors.append(f"`comments[{index}]` must be an object.")
+            continue
+
+        path = normalize_review_path(raw_comment.get("path"))
+        line = raw_comment.get("line")
+        body_value = raw_comment.get("body")
+        body = body_value.strip() if isinstance(body_value, str) else ""
+        side = raw_comment.get("side")
+
+        if not path:
+            errors.append(f"`comments[{index}]` is missing `path`.")
+            continue
+        if path not in diff_line_map:
+            errors.append(
+                f"`comments[{index}]` references `{path}`, which is not part of the PR diff. Move that feedback to top-level `body` instead."
+            )
+            continue
+        if not isinstance(line, int) or line <= 0:
+            errors.append(
+                f"`comments[{index}]` for `{path}` must include a positive integer `line`."
+            )
+            continue
+        if side not in {"LEFT", "RIGHT"}:
+            errors.append(
+                f"`comments[{index}]` for `{path}:{line}` must include `side` set to `LEFT` or `RIGHT`."
+            )
+            continue
+        if not body:
+            errors.append(f"`comments[{index}]` for `{path}` is missing `body`.")
+            continue
+
+        allowed_lines = diff_line_map[path][side]
+        if line not in allowed_lines:
+            errors.append(
+                f"`comments[{index}]` references `{path}:{line}` on `{side}`, which is not commentable in the PR diff."
+            )
+            continue
+
+        normalized_comment: ReviewComment = {
+            "path": path,
+            "line": line,
+            "side": side,
+            "body": body,
+        }
+
+        if "start_line" in raw_comment and raw_comment.get("start_line") is not None:
+            start_line = raw_comment.get("start_line")
+            if not isinstance(start_line, int) or start_line <= 0:
+                errors.append(
+                    f"`comments[{index}]` for `{path}` has invalid `start_line`; it must be a positive integer."
+                )
+                continue
+            start_side = raw_comment.get("start_side")
+            if start_side not in {"LEFT", "RIGHT"}:
+                errors.append(
+                    f"`comments[{index}]` for `{path}` has `start_line` but is missing `start_side`; set `start_side` to `LEFT` or `RIGHT`."
+                )
+                continue
+            if start_side == side and start_line >= line:
+                errors.append(
+                    f"`comments[{index}]` for `{path}` has invalid `start_line`; when `start_side` matches `side`, it must be smaller than `line`."
+                )
+                continue
+            if start_line not in diff_line_map[path][start_side]:
+                errors.append(
+                    f"`comments[{index}]` references `{path}:{start_line}` on `{start_side}` as `start_line`, which is not commentable in the PR diff."
+                )
+                continue
+            normalized_comment["start_line"] = start_line
+            normalized_comment["start_side"] = start_side
+        elif raw_comment.get("start_side") is not None:
+            errors.append(
+                f"`comments[{index}]` for `{path}:{line}` has `start_side` without `start_line`."
+            )
+            continue
+
+        if diff_content_map is not None:
+            suggestion_errors = _validate_suggestion_blocks(
+                normalized_comment, diff_content_map
+            )
+            if suggestion_errors:
+                for err in suggestion_errors:
+                    errors.append(
+                        f"`comments[{index}]` for `{path}:{line}` on `{side}` has an invalid suggestion block: {err}."
+                    )
+                continue
+
+        normalized_comments.append(normalized_comment)
+
+    return ReviewValidationResult(
+        body=raw_body.strip(),
+        comments=normalized_comments,
+        errors=errors,
+    )
+
+
+def _load_json(path: Path) -> Any:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        raise SystemExit(f"review validation failed: {path} does not exist")
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"review validation failed: {path} is invalid JSON: {exc}")
+
+
+def _validate_verdict(payload: Any) -> list[str]:
+    if not isinstance(payload, dict):
+        return ["review.json must decode to a JSON object."]
+    verdict = payload.get("verdict")
+    if verdict not in {"APPROVE", "REJECT"}:
+        return ['`verdict` must be exactly "APPROVE" or "REJECT".']
+    return []
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Validate review.json comments against annotated pr_diff.txt."
+    )
+    parser.add_argument(
+        "--review-json",
+        default="review.json",
+        type=Path,
+        help="Path to the review.json artifact to validate.",
+    )
+    parser.add_argument(
+        "--diff",
+        default="pr_diff.txt",
+        type=Path,
+        help="Path to the annotated PR diff consumed during review.",
+    )
+    args = parser.parse_args()
+
+    payload = _load_json(args.review_json)
+    try:
+        diff_text = args.diff.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        print(f"review validation failed: {args.diff} does not exist", file=sys.stderr)
+        return 1
+
+    diff_line_map, diff_content_map = build_diff_maps_from_annotated_diff(diff_text)
+    result = validate_review_payload(payload, diff_line_map, diff_content_map)
+    errors = _validate_verdict(payload) + result.errors
+    if errors:
+        print("review validation failed:", file=sys.stderr)
+        for error in errors:
+            print(f"- {error}", file=sys.stderr)
+        return 1
+
+    print(
+        "review validation passed: "
+        f"{len(result.comments)} inline comment(s), {len(diff_line_map)} diff file(s)"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/framework/skills/unslop/SKILL.md

@@ -14,6 +14,12 @@ Edit text to remove AI patterns and add human voice.
 2. Rewrite. Preserve meaning, match intended tone.
 3. Add soul (see next section).
 4. Self-audit: "What makes this obviously AI generated?" Fix remaining tells.
+5. Output the full edited draft plus a short **What changed** section listing the patterns fixed.
+6. Run the checks in [eval.md](references/eval.md). If any check fails, fix the draft and re-check.
+
+## Detect mode
+
+When the user asks whether a piece is slop, or asks to audit, scan, or flag a draft without rewriting: name each pattern from this skill that appears, quote the line, and give the fix in a few words. Do not rewrite, score the draft, or guess whether AI wrote it. Offer to edit the draft after.
 
 ## Adding soul
 
@@ -39,7 +45,7 @@ Removing patterns is half the job. Sterile, voiceless writing is just as obvious
 
 ### Language
 
-7. **AI vocabulary.** Additionally, crucial, delve, enduring, enhance, fostering, garner, interplay, intricate, landscape (abstract), pivotal, showcase, tapestry (abstract), testament, underscore, vibrant. Replace with plain words.
+7. **AI vocabulary.** Additionally, beacon, crucial, cutting-edge, delve, empower, embark, elevate, enduring, enhance, ever-evolving, fostering, game changer, garner, interplay, intricate, landscape (abstract), meticulous, multifaceted, paradigm shift, paramount, pivotal, realm, robust, showcase, streamline, supercharge, tapestry (abstract), testament, this changes everything, this is huge, transformative, underscore, vibrant. Replace with plain words.
 8. **Fancy ways to say "is".** "serves as", "stands as", "boasts", "features". Just say "is" or "has".
 9. **"Not just X, but Y."** State the point directly instead.
 10. **Rule of three.** Forcing ideas into groups of three. Use the natural number.
@@ -64,8 +70,8 @@ Removing patterns is half the job. Sterile, voiceless writing is just as obvious
 
 ### Filler
 
-23. **Filler phrases.** "In order to" becomes "To". "Due to the fact that" becomes "Because". "It is important to note that" gets deleted.
-24. **Excessive hedging.** "could potentially possibly be argued that it might" becomes "may".
+23. **Filler phrases.** "In order to" becomes "To". "Due to the fact that" becomes "Because". "It is important to note that" gets deleted. Often-empty phrases that delay the point: it's worth noting, at the end of the day, when it comes to, at its core, in today's world, in the age of, in the world of, the reality is, the truth is, in terms of, with regard to, going forward, in this article, let's dive in. Cut them unless part of the writer's recognizable voice.
+24. **Excessive hedging.** "could potentially possibly be argued that it might" becomes "may". Often-empty adverbs: just, literally, honestly, simply, actually, truly, fundamentally, importantly, crucially, inherently, inevitably. Cut when they add nothing; keep when they carry emphasis, uncertainty, contrast, or spoken rhythm.
 25. **Generic conclusions.** "The future looks bright." State specific plans or facts.
 
 ### Jargon
@@ -79,3 +85,28 @@ Removing patterns is half the job. Sterile, voiceless writing is just as obvious
 29. **Active voice.** Prefer it. Catch "is/are/was/were + past participle" and name the actor: "queries are validated" becomes "the compiler validates queries", "the file is parsed by the loader" becomes "the loader parses the file". Passive is fine only when the actor is unknown or genuinely doesn't matter.
 30. **Cut adverbs, or use a stronger verb.** "runs quickly" becomes "is fast" or the number. "significantly improves" becomes the measured delta. An adverb propping up a weak verb means the verb is wrong.
 31. **Prefer the plain word.** "utilize" becomes "use", "leverage" becomes "use", "facilitate" becomes "help", "numerous" becomes "many", "in the event that" becomes "if". The fancier synonym is rarely clearer.
+
+### Voice preservation (from no-ai-slop)
+
+32. **Minimum effective edit.** Fix AI patterns, errors, repetition, and unclear passages. Leave strong human sentences alone. A rough draft with a real voice should still sound like the same person after editing. Do not make every paragraph equally tidy.
+33. **Show, don't label.** Cut commentary that labels a point important, surprising, subtle, or obvious instead of demonstrating why ("That last part matters more than it sounds", "The key point is", "As you can see", "This distinction matters", redundant "In other words"). If the prose already shows the point, delete the aside. Otherwise replace it with facts.
+34. **Protect the specific fact.** Don't smooth a useful detail into generic importance. "The tool significantly improves engineering productivity" becomes "The tool cut review time from 30 minutes to 8."
+35. **Portability test.** If a sentence could move unchanged to another person, company, country, or product, it is filler. Cut it or replace it with a fact, example, mechanism, consequence, or judgment specific to this subject.
+
+### Dramatic setups and endings (from no-ai-slop)
+
+36. **Throat-clearing openers.** "Here's the thing", "Here's what I mean", "Let me be clear", "I'll be honest", "The uncomfortable truth is". Cut and state the point. Keep a personal aside only when it creates context, tension, or character.
+37. **Faux-insight setups.** "What nobody tells you", "What most people get wrong", "The part everyone misses", "This is the part most people skip". These flatter the writer as the lone expert. Cut the setup; make the claim stand on its own.
+38. **Binary contrasts.** "It's not X. It's Y.", "The question isn't X, it's Y." State Y directly. "The question isn't the model. It's the eval." becomes "The eval matters more than the model." (See also 9.)
+39. **Negative listing.** "Not a X. Not a Y. A Z." Just say Z.
+40. **Rhetorical setups.** "What if I told you...", "Think about it:", "Plot twist:", self-answered "Question? Answer." pairs. Drop them and make the point.
+41. **Colon reveals.** A noun phrase, a colon, then a lowercase dramatic reveal: "The best part: it learns." Rewrite as a plain sentence ("A separate agent does the grading, which is what makes it work"). Colons are for lists, labels, and quotes, not fake drama. (See also 14.)
+42. **Dramatic fragmentation.** "That's it. That's the whole thing.", "X. And Y. And Z." Use complete sentences unless the fragment is clearly the writer's own cadence.
+43. **Robotic rhythm.** Repeated sentence shapes, identical paragraph structures, stacked punchy fragments. Vary the shape only when it helps the point.
+44. **Fake-profound kickers.** Cut the final "deep" line when it turns the point into a metaphor, aphorism, or mic-drop ("The future isn't coming. It's already here."). Do not rewrite it into a better metaphor. Delete it, then end on the clearest concrete sentence already in the draft.
+45. **Summary-recap endings.** "In conclusion", "Ultimately", "Overall", or a final paragraph restating the piece. The reader was just there. End on the last concrete point, takeaway, or next action instead. (See also 25.)
+46. **Formatting slop.** Bullet lists where two sentences of prose would read better, headers over two-sentence sections. Format follows the content, not decorates it. (See also 15, 18.)
+
+## Source
+
+Patterns 32–46, detect mode, and `references/eval.md` adapted from [no-ai-slop](https://github.com/petergyang/no-ai-slop) by Peter Yang, MIT License.

package/framework/skills/unslop/examples.md

@@ -3,3 +3,5 @@
 - Rewrite release notes to remove inflated claims, filler, and generic AI phrasing while preserving meaning.
 - Edit technical prose for plain language, varied rhythm, active voice, and a natural human tone.
 - Scan a document for em-dash overuse, formulaic transitions, vague claims, and unnecessary jargon before rewriting it.
+- Detect mode: flag each slop pattern with a quoted line and a short fix, without rewriting. Example: "`The best part: it learns.` — colon reveal (41). Rewrite as a plain sentence."
+- Minimum effective edit: leave strong human sentences alone. Example: keep the writer's blunt aside, cut only the throat-clearing opener and the fake-profound kicker.

package/framework/skills/unslop/references/eval.md

@@ -0,0 +1,44 @@
+# Unslop eval
+
+Use after the rewrite. Answer each check with pass or fail. If any check fails, fix the draft before returning it.
+
+For detect requests, make sure the response names each pattern found with a quoted line and a short fix, without rewriting the draft.
+
+## Edit integrity
+
+1. Does the edit preserve the user's point without adding claims, examples, stats, quotes, or opinions?
+2. Does it preserve the writer's distinctive vocabulary, cadence, bluntness, humor, uncertainty, and level of polish (32)?
+3. Does it leave strong human sentences alone instead of making every paragraph equally tidy (32)?
+4. Is the amount of cutting proportional to the actual slop, with no aggressive compression that strips out character?
+5. Does the draft lead with what the reader needs while keeping personal setup that adds context, tension, or character (36)?
+6. Do sentences earn their place, with concrete facts, protected details (34), and direct verbs?
+7. Does every generic sentence pass the portability test (35), or was it cut or made specific?
+8. Does the draft use active voice with human subjects where possible (29)?
+9. Are genuinely tangled sentences fixed while clear spoken cadence and changes in pace remain intact (28)?
+
+## Words to cut
+
+1. Are banned words (7), filler phrases (23), often-empty adverbs (24), and inflated claims removed unless quoted as examples?
+
+## Patterns to cut
+
+1. Are binary contrasts (9, 38), negative listings (39), rhetorical setups (40), and throat-clearing openers (36) removed?
+2. Are faux-insight setups (37), colon reveals (41), superficial -ing phrases (3), fancy "is" verbs (8), synonym cycling (11), dramatic fragments (42), and robotic rhythm (43) fixed?
+3. Are puffery (1), promotional language (4), and vague attributions (5) replaced with plain facts and named sources, or flagged when no source exists?
+4. Is interpretive metadiscourse (33) removed, including emphasis markers and redundant glossing?
+5. Are fake-profound kickers (44) deleted instead of rewritten into better metaphors?
+6. Are summary-recap endings (45) cut so the piece ends on a concrete point, takeaway, or next action?
+7. Is formatting slop removed: decorative emoji (18), decorative bold (15), bullets that should be prose, headers over tiny sections (46)?
+8. Are em dashes (13), colons (14), title case headings (17), and curly quotes (19) fixed?
+
+## Final read
+
+1. Does the draft avoid robotic symmetry, repeated sentence shapes, and stacked punchy fragments (43)?
+2. Would the writer recognize the edited draft as their own voice?
+3. Would the edited draft sound natural if read to a sharp colleague?
+4. Does the final output include the full edited draft and a short **What changed** section?
+5. For detect requests, does the response name each pattern with a quoted line and a short fix, without rewriting, scoring, or claiming AI authorship?
+
+## Source
+
+Adapted from [no-ai-slop](https://github.com/petergyang/no-ai-slop) `eval.md` by Peter Yang, MIT License.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohammadhprp/system-prompt",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "description": "AI Coding Agent Framework — interactive bootstrap CLI",
   "keywords": [
     "ai",

package/src/catalog.js

@@ -4,6 +4,7 @@ export const categories = {
     description: 'Task-specific procedures for AI coding agents',
     sourceDir: 'framework/skills',
     items: [
+      { id: 'adhd', name: 'ADHD', description: 'Shape output for ADHD readers: action first, numbered steps, restated state, no tangents' },
       { id: 'agent-browser', name: 'Agent Browser', description: 'Automate browser and Electron workflows for navigation, testing, screenshots, and data extraction' },
       { id: 'architect', name: 'Architect', description: 'Sketch architecture and module boundaries before implementation' },
       { id: 'arena', name: 'Arena', description: 'Compare parallel candidate solutions and synthesize the strongest result' },
@@ -16,6 +17,7 @@ export const categories = {
       { id: 'effective-html', name: 'Effective HTML', description: 'Create self-contained HTML artifacts with routed guidance for design, wireframes, prototypes, plans, and diagrams' },
       { id: 'find-skills', name: 'Find Skills', description: 'Discover, evaluate, and install agent skills for specialized tasks' },
       { id: 'frontend-design', name: 'Frontend Design', description: 'Distinctive, intentional visual design for new UI or reshaping existing UI' },
+      { id: 'gh', name: 'GitHub CLI', description: 'Work with GitHub via the gh CLI for repositories, issues, pull requests, Actions, releases, and APIs' },
       { id: 'glab', name: 'Glab', description: 'Work with GitLab via the glab CLI for MRs, issues, and pipelines' },
       { id: 'humanizer', name: 'Humanizer', description: 'Remove signs of AI-generated writing to make text sound more natural and human' },
       { id: 'improve', name: 'Improve', description: 'Audit repositories and produce prioritized, read-only implementation plans for another agent' },
@@ -24,9 +26,10 @@ export const categories = {
       { id: 'laravel-best-practices', name: 'Laravel Best Practices', description: 'Laravel patterns for Eloquent, validation, testing' },
       { id: 'merge-request', name: 'Merge Request', description: 'Create a GitLab merge request (MR) for the current branch' },
       { id: 'perf-web-optimization', name: 'Web Performance Optimization', description: 'Optimize web performance: bundle size, images, caching, lazy loading, and overall page speed' },
+      { id: 'ponytail', name: 'Ponytail', description: 'Lazy senior developer workflow focused on YAGNI, reuse, and the smallest working change' },
       { id: 'pull-request', name: 'Pull Request', description: 'Create or update a GitHub pull request (PR) for the current branch' },
       { id: 'release', name: 'Release', description: 'Prepare and tag semantic-versioned releases' },
-      { id: 'review', name: 'Review', description: 'Perform comprehensive code quality review' },
+      { id: 'review', name: 'Review', description: 'Review local, GitHub, or GitLab changes and write review.json' },
       { id: 'security-best-practices', name: 'Security Best Practices', description: 'Language and framework specific security best-practice reviews and secure-by-default coding help' },
       { id: 'sentry', name: 'Sentry', description: 'Inspect Sentry issues, summarize production errors, and pull health data via the Sentry API' },
       { id: 'show-me', name: 'Show Me', description: 'Explain the current topic visually with diagrams, code-shape sketches, and focused HTML artifacts' },
@@ -55,13 +58,9 @@ export const categories = {
     description: 'Slash command workflows for repeatable tasks',
     sourceDir: 'framework/commands',
     items: [
-      { id: 'changelog', name: 'Changelog', description: 'Create, add, or update CHANGELOG.md entries' },
-      { id: 'commit', name: 'Commit', description: 'Create atomic git commits with conventional messages' },
+      { id: 'audit-your-codebase', name: 'Audit Your Codebase', description: 'Audit for materially useful simplifications in structure, state, algorithms, and ownership' },
+      { id: 'explain-codebase', name: 'Explain Codebase', description: 'Map a codebase and teach it interactively, from overview to focused deep-dives' },
       { id: 'learn', name: 'Learn', description: 'Distill a reusable skill from any source' },
-      { id: 'pr', name: 'PR', description: 'Create a GitHub PR for the current branch' },
-      { id: 'mr', name: 'MR', description: 'Create a GitLab MR for the current branch' },
-      { id: 'release', name: 'Release', description: 'Tag releases, update changelog, and bump versions' },
-      { id: 'review', name: 'Review', description: 'Perform comprehensive code quality review' },
       { id: 'summarize-changes', name: 'Summarize Changes', description: 'Summarize uncommitted changes and flag risks' },
     ],
   },

package/framework/commands/changelog.md

@@ -1,44 +0,0 @@
----
-description: Create, add, or update entries in CHANGELOG.md
-agent: build
----
-
-Changelog $ARGUMENTS
-
-Maintain CHANGELOG.md entries for my changes.
-
-## Process
-
-1. **Review and categorize** - Review conversation history, read current `CHANGELOG.md`, determine if changes are `Added`, `Changed`, `Fixed`, `Removed`, `Deprecated`, or `Security`. Read the existing `## Unreleased` section.
-
-2. **Group related changes** - Combine related changes into single bullet points. Use past tense ("Added...", "Fixed..."). Include file paths or component names in backticks when helpful. Match existing style and tone.
-
-3. **Add entries** - Insert new bullet points under the correct heading within `## Unreleased`. Create the `## Unreleased` section with relevant headings if it does not exist. Preserve all existing entries.
-
-4. **Verify** - Read the final `CHANGELOG.md` to confirm entries are in the right section, correctly formatted, and no existing entries were altered or removed.
-
-## Entry Format
-
-```markdown
-## Unreleased
-
-### Added
-- New features, entries, additions.
-
-### Changed
-- Changes in existing functionality, refactors, renames.
-
-### Fixed
-- Bug fixes, corrections.
-
-### Removed
-- Removed features, files, entries.
-
-### Deprecated
-- Soon-to-be-removed features.
-
-### Security
-- Vulnerabilities, security fixes.
-```
-
-**Note:** Group entries by section. Order sections: Added, Changed, Fixed, Removed, Deprecated, Security. Within each section, entries are reverse-chronological (newest first). Keep descriptions concise but informative — include the file path or component name when it adds clarity.

package/framework/commands/commit.md

@@ -1,28 +0,0 @@
----
-description: Create atomic git commits with conventional messages
-agent: build
----
-
-Commit $ARGUMENTS
-
-Create git commits for my changes.
-
-## Process
-
-1. **Analyze and plan** - Review conversation history, run `git status -s` and `git diff`, determine if changes should be one or multiple logical commits, group related files, draft conventional commit messages (`type: description`) in imperative mood focusing on why
-2. **Present plan** - List files for each commit, show commit messages with type prefix, ask: "I plan to create [N] commit(s) with these changes. Shall I proceed?"
-3. **Execute upon confirmation** - Use `git add` with specific files (never `-A` or `.`), create commits with planned messages, show result with `git log --oneline -n [N]`
-
-## Commit Message Format
-
-Use conventional commit format: `type: description`
-
-**Types:**
-- `feat:` - New feature (user-facing)
-- `fix:` - Bug fix (user-facing)
-- `docs:` - Documentation only
-- `chore:` - Maintenance, tooling, dependencies
-- `refactor:` - Code restructuring without behavior change
-- `test:` - Adding or updating tests
-- `perf:` - Performance improvement
-- `ci:` - CI/CD changes

package/framework/commands/mr.md

@@ -1,45 +0,0 @@
----
-description: Create a merge request from the current branch
----
-
-Create $ARGUMENTS merge request
-
-Create a merge request for the current branch.
-
-## Process
-
-1. **Collect information**
-   - Get current branch name: `git branch --show-current`
-   - Read MR template from `.gitlab/merge_request_templates/default.md` of exsits
-
-2. **Format MR title**
-   - Take the branch name, replace all `-` with spaces, capitalize first character
-
-3. **Collect commits and build summary**
-   - List commits on the branch that are not on `dev`: `git log dev..HEAD --oneline`
-   - Read each commit message, convert to a bullet list summarizing user-facing changes
-   - Merge/squash related commits (e.g. multiple commits for the same change)
-   - Keep concise, one bullet per logical change
-
-4. **Fill template**
-   - Set Summary to the bullet list from step 3
-   - Keep the Checklist section as-is
-
-5. **Present plan and confirm** - Show:
-   - Source branch
-   - Target branch: `develop`
-   - Title
-   - Filled description
-   - Ask: "Shall I create this MR?"
-   - Push the changes if user says Yes
-
-6. **Create upon confirmation** - Use `glab mr create`:
-   - `--source-branch`: Current branch
-   - `--target-branch`: `develop`
-   - `--title`: Prepend "Draft: " to the formatted branch name
-   - `--description`: Filled template content
-   - `--assignee`: `1`
-   - `--squash`
-   - `--remove-source-branch`
-
-7. **Show the resulting URL.**