release-note-readiness-desk 0.1.0__tar.gz

release_note_readiness_desk-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Haider Sattar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

release_note_readiness_desk-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include examples *.md
+recursive-include docs *.svg

release_note_readiness_desk-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: release-note-readiness-desk
+Version: 0.1.0
+Summary: Local CLI and desktop checker for release note readiness gaps
+Author: Haider Sattar
+License-Expression: MIT
+Keywords: release-notes,changelog,product,qa,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+![Release Note Readiness desktop preview](docs/screenshot.svg)
+
+# Release Note Readiness Desk
+
+Release Note Readiness Desk checks changelog drafts, PR summaries, and release-note copy for gaps that usually cause avoidable release confusion: missing migration steps, unclear customer impact, vague bullets, unresolved placeholders, absent validation evidence, and missing rollback notes.
+
+It runs locally as a CLI or a small Tkinter desktop app. There are no runtime dependencies.
+
+## Install
+
+```bash
+python3 -m pip install release-note-readiness-desk
+```
+
+## CLI
+
+```bash
+release-note-readiness examples/release-draft.md
+release-note-readiness examples/release-draft.md --format html --output readiness.html
+release-note-readiness CHANGELOG.md --fail-under 80 --fail-on-high
+```
+
+Read from stdin:
+
+```bash
+cat CHANGELOG.md | release-note-readiness --format json
+```
+
+## Desktop App
+
+```bash
+release-note-readiness-gui
+```
+
+Paste a draft, click **Check**, then copy or save the Markdown report.
+
+## What It Checks
+
+- Breaking or high-risk changes without migration guidance
+- Risky changes without customer impact language
+- Missing validation or rollout evidence
+- Missing rollback, revert, or feature-flag notes
+- Draft placeholders such as `TODO` or `TBD`
+- Vague entries like "minor updates" or "various fixes"
+- Missing standard release-note categories
+
+## Development
+
+```bash
+python3 -m unittest discover -s tests
+python3 -m build --no-isolation
+python3 -m twine check dist/*
+```
+
+## License
+
+MIT

release_note_readiness_desk-0.1.0/README.md

@@ -0,0 +1,57 @@
+![Release Note Readiness desktop preview](docs/screenshot.svg)
+
+# Release Note Readiness Desk
+
+Release Note Readiness Desk checks changelog drafts, PR summaries, and release-note copy for gaps that usually cause avoidable release confusion: missing migration steps, unclear customer impact, vague bullets, unresolved placeholders, absent validation evidence, and missing rollback notes.
+
+It runs locally as a CLI or a small Tkinter desktop app. There are no runtime dependencies.
+
+## Install
+
+```bash
+python3 -m pip install release-note-readiness-desk
+```
+
+## CLI
+
+```bash
+release-note-readiness examples/release-draft.md
+release-note-readiness examples/release-draft.md --format html --output readiness.html
+release-note-readiness CHANGELOG.md --fail-under 80 --fail-on-high
+```
+
+Read from stdin:
+
+```bash
+cat CHANGELOG.md | release-note-readiness --format json
+```
+
+## Desktop App
+
+```bash
+release-note-readiness-gui
+```
+
+Paste a draft, click **Check**, then copy or save the Markdown report.
+
+## What It Checks
+
+- Breaking or high-risk changes without migration guidance
+- Risky changes without customer impact language
+- Missing validation or rollout evidence
+- Missing rollback, revert, or feature-flag notes
+- Draft placeholders such as `TODO` or `TBD`
+- Vague entries like "minor updates" or "various fixes"
+- Missing standard release-note categories
+
+## Development
+
+```bash
+python3 -m unittest discover -s tests
+python3 -m build --no-isolation
+python3 -m twine check dist/*
+```
+
+## License
+
+MIT

release_note_readiness_desk-0.1.0/docs/screenshot.svg

@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1100" height="620" viewBox="0 0 1100 620" role="img" aria-label="Release Note Readiness desktop preview">
+  <rect width="1100" height="620" fill="#f7f8fb"/>
+  <rect x="34" y="30" width="1032" height="560" rx="8" fill="#ffffff" stroke="#d7dee9"/>
+  <rect x="34" y="30" width="1032" height="54" rx="8" fill="#17202a"/>
+  <text x="58" y="64" font-family="Arial, sans-serif" font-size="20" fill="#ffffff" font-weight="700">Release Note Readiness</text>
+  <rect x="58" y="112" width="470" height="430" rx="6" fill="#fbfcfe" stroke="#d7dee9"/>
+  <text x="78" y="145" font-family="Arial, sans-serif" font-size="16" fill="#17202a" font-weight="700">Draft</text>
+  <text x="78" y="184" font-family="Menlo, monospace" font-size="15" fill="#26313f"># Breaking</text>
+  <text x="78" y="214" font-family="Menlo, monospace" font-size="15" fill="#26313f">- Removed legacy invoice.status values</text>
+  <text x="78" y="244" font-family="Menlo, monospace" font-size="15" fill="#26313f"># Validation</text>
+  <text x="78" y="274" font-family="Menlo, monospace" font-size="15" fill="#26313f">- Verified with webhook replay tests</text>
+  <rect x="572" y="112" width="470" height="430" rx="6" fill="#fbfcfe" stroke="#d7dee9"/>
+  <text x="592" y="145" font-family="Arial, sans-serif" font-size="16" fill="#17202a" font-weight="700">Readiness Report</text>
+  <text x="592" y="194" font-family="Arial, sans-serif" font-size="48" fill="#175cd3" font-weight="800">89/100</text>
+  <rect x="592" y="222" width="76" height="28" rx="6" fill="#e7f0ff"/>
+  <text x="608" y="241" font-family="Arial, sans-serif" font-size="14" fill="#175cd3" font-weight="700">ready</text>
+  <text x="592" y="294" font-family="Arial, sans-serif" font-size="16" fill="#26313f">No blocking findings.</text>
+  <text x="592" y="338" font-family="Arial, sans-serif" font-size="16" fill="#26313f">Action: publish after owner review.</text>
+</svg>
+

release_note_readiness_desk-0.1.0/examples/release-draft.md

@@ -0,0 +1,19 @@
+# Added
+- Added workspace-level export for audit admins and customer success teams.
+- Added API support for project-level usage summaries.
+
+# Changed
+- Changed invoice webhook payload defaults for developers.
+- Updated admin settings layout after staging QA.
+
+# Breaking
+- Removed legacy invoice.status values from the public API.
+
+# Migration
+- Developers should map old invoice.status values to the documented open, paid, and void states before upgrading.
+
+# Validation
+- Verified in staging with webhook replay tests and canary monitoring.
+
+# Rollback
+- Release can be disabled with the invoice_webhook_v2 feature flag.

release_note_readiness_desk-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "release-note-readiness-desk"
+version = "0.1.0"
+description = "Local CLI and desktop checker for release note readiness gaps"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Haider Sattar"}]
+keywords = ["release-notes", "changelog", "product", "qa", "developer-tools"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Environment :: MacOS X",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Text Processing",
+]
+
+[project.scripts]
+release-note-readiness = "release_note_readiness.cli:main"
+release-note-readiness-gui = "release_note_readiness.desktop:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

release_note_readiness_desk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

release_note_readiness_desk-0.1.0/src/release_note_readiness/__init__.py

@@ -0,0 +1,6 @@
+"""Release note readiness checks."""
+
+from .core import Finding, ReleaseNoteReport, Section, analyze_notes
+
+__all__ = ["Finding", "ReleaseNoteReport", "Section", "analyze_notes"]
+

release_note_readiness_desk-0.1.0/src/release_note_readiness/cli.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+from .core import analyze_notes, format_html, format_json, format_markdown, format_text
+
+
+FORMATTERS = {
+    "text": format_text,
+    "markdown": format_markdown,
+    "json": format_json,
+    "html": format_html,
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Check release note drafts for readiness gaps.")
+    parser.add_argument("path", nargs="?", help="Release note draft file. Reads stdin when omitted.")
+    parser.add_argument("--format", choices=sorted(FORMATTERS), default="markdown", help="Output format.")
+    parser.add_argument("--output", help="Write the report to a file.")
+    parser.add_argument("--fail-under", type=int, default=None, help="Exit 2 when readiness score is below this value.")
+    parser.add_argument("--fail-on-high", action="store_true", help="Exit 2 when high-severity findings are present.")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    text = Path(args.path).read_text(encoding="utf-8") if args.path else sys.stdin.read()
+    report = analyze_notes(text)
+    rendered = FORMATTERS[args.format](report)
+    if args.output:
+        Path(args.output).write_text(rendered, encoding="utf-8")
+    else:
+        sys.stdout.write(rendered)
+    if args.fail_under is not None and report.score < args.fail_under:
+        return 2
+    if args.fail_on_high and any(finding.level == "high" for finding in report.findings):
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

release_note_readiness_desk-0.1.0/src/release_note_readiness/core.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import html
+import json
+import re
+from typing import Iterable
+
+
+CATEGORY_KEYWORDS = {
+    "breaking": ("breaking", "removed", "deprecate", "incompatible", "migration", "migrate"),
+    "security": ("security", "vulnerability", "cve", "permission", "auth", "token", "secret"),
+    "fixed": ("fix", "fixed", "bug", "patch", "resolve", "crash", "error"),
+    "added": ("add", "added", "new", "launch", "support", "introduce"),
+    "changed": ("change", "changed", "update", "improve", "refactor", "rename"),
+    "deprecated": ("deprecated", "sunset", "remove in", "end of life"),
+}
+
+SECTION_ALIASES = {
+    "added": "added",
+    "new": "added",
+    "fixed": "fixed",
+    "bug fixes": "fixed",
+    "changed": "changed",
+    "updated": "changed",
+    "breaking": "breaking",
+    "breaking changes": "breaking",
+    "migration": "migration",
+    "migrations": "migration",
+    "upgrade notes": "migration",
+    "security": "security",
+    "deprecated": "deprecated",
+    "known issues": "known-issues",
+    "rollback": "rollback",
+    "validation": "validation",
+}
+
+HIGH_RISK_TERMS = (
+    "breaking",
+    "remove",
+    "deleted",
+    "migration",
+    "schema",
+    "database",
+    "billing",
+    "invoice",
+    "auth",
+    "permission",
+    "security",
+    "token",
+    "api",
+    "webhook",
+    "default",
+    "deprecate",
+)
+
+VALIDATION_TERMS = ("tested", "verified", "qa", "rollout", "canary", "staging", "monitor")
+ROLLBACK_TERMS = ("rollback", "revert", "feature flag", "kill switch", "disable")
+CUSTOMER_TERMS = ("customer", "user", "admin", "developer", "tenant", "account", "workspace")
+
+
+@dataclass(frozen=True)
+class Section:
+    name: str
+    items: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class Finding:
+    level: str
+    title: str
+    detail: str
+    evidence: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class ReleaseNoteReport:
+    score: int
+    readiness: str
+    sections: tuple[Section, ...]
+    findings: tuple[Finding, ...]
+    action_items: tuple[str, ...]
+    summary: str
+
+    def to_dict(self) -> dict:
+        return {
+            "score": self.score,
+            "readiness": self.readiness,
+            "summary": self.summary,
+            "sections": [{"name": section.name, "items": list(section.items)} for section in self.sections],
+            "findings": [
+                {
+                    "level": finding.level,
+                    "title": finding.title,
+                    "detail": finding.detail,
+                    "evidence": list(finding.evidence),
+                }
+                for finding in self.findings
+            ],
+            "action_items": list(self.action_items),
+        }
+
+
+def analyze_notes(text: str) -> ReleaseNoteReport:
+    cleaned = text.strip()
+    sections = _parse_sections(cleaned)
+    items = [item for section in sections for item in section.items]
+    findings: list[Finding] = []
+
+    if not cleaned:
+        findings.append(Finding("high", "No release notes supplied", "Paste a draft or changelog before publishing."))
+        return ReleaseNoteReport(0, "blocked", tuple(), tuple(findings), ("Add release notes.",), "No usable release note content was found.")
+
+    if len(items) < 2:
+        findings.append(Finding("medium", "Very thin draft", "The note has too few concrete items to support release review."))
+
+    has_customer_impact = _contains_any(cleaned, CUSTOMER_TERMS)
+    has_validation = _contains_any(cleaned, VALIDATION_TERMS) or _has_section(sections, "validation")
+    has_rollback = _contains_any(cleaned, ROLLBACK_TERMS) or _has_section(sections, "rollback")
+    has_migration = _has_section(sections, "migration") or _contains_any(cleaned, ("migration", "migrate", "upgrade"))
+    risky_items = tuple(item for item in items if _contains_any(item, HIGH_RISK_TERMS))
+    breaking_items = tuple(item for item in items if _classify_item(item) == "breaking")
+    vague_items = tuple(item for item in items if _is_vague(item))
+    placeholder_items = tuple(item for item in items if re.search(r"\b(tbd|todo|fixme|lorem|placeholder|xxx)\b", item, re.I))
+
+    if risky_items and not has_customer_impact:
+        findings.append(Finding("high", "Customer impact missing", "Risky changes should say who is affected and what changes for them.", risky_items[:3]))
+    if (risky_items or breaking_items) and not has_migration:
+        findings.append(Finding("high", "Migration notes missing", "Breaking or high-risk changes need explicit upgrade or migration guidance.", breaking_items[:3] or risky_items[:3]))
+    if risky_items and not has_validation:
+        findings.append(Finding("medium", "Validation evidence missing", "Include how the change was tested, staged, or monitored.", risky_items[:3]))
+    if risky_items and not has_rollback:
+        findings.append(Finding("medium", "Rollback note missing", "High-risk releases should include a rollback or disable path.", risky_items[:3]))
+    if placeholder_items:
+        findings.append(Finding("high", "Draft placeholders remain", "Remove unresolved placeholders before publishing.", placeholder_items[:3]))
+    if vague_items:
+        findings.append(Finding("medium", "Vague entries", "Rewrite vague entries so readers can understand the shipped behavior.", vague_items[:4]))
+    if not _has_any_release_category(sections, items):
+        findings.append(Finding("medium", "No recognizable release categories", "Use clear Added, Changed, Fixed, Security, Deprecated, or Breaking sections."))
+
+    score = _score(findings, sections, items, has_customer_impact, has_validation, has_rollback)
+    has_high = any(finding.level == "high" for finding in findings)
+    readiness = "blocked" if has_high else "ready" if score >= 85 else "needs review" if score >= 65 else "blocked"
+    action_items = _action_items(findings)
+    summary = _summary(score, readiness, sections, findings)
+    return ReleaseNoteReport(score, readiness, sections, tuple(findings), action_items, summary)
+
+
+def format_markdown(report: ReleaseNoteReport) -> str:
+    lines = [
+        "# Release Note Readiness",
+        "",
+        f"Score: **{report.score}/100**",
+        f"Status: **{report.readiness}**",
+        "",
+        report.summary,
+        "",
+        "## Findings",
+    ]
+    if report.findings:
+        for finding in report.findings:
+            lines.append(f"- **{finding.level.upper()} - {finding.title}:** {finding.detail}")
+            for evidence in finding.evidence:
+                lines.append(f"  - Evidence: {evidence}")
+    else:
+        lines.append("- No blocking findings.")
+    lines.extend(["", "## Action Items"])
+    for item in report.action_items:
+        lines.append(f"- {item}")
+    lines.extend(["", "## Parsed Sections"])
+    for section in report.sections:
+        lines.append(f"### {section.name.title()}")
+        for item in section.items:
+            lines.append(f"- {item}")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def format_text(report: ReleaseNoteReport) -> str:
+    lines = [f"Release Note Readiness: {report.score}/100 ({report.readiness})", report.summary, ""]
+    lines.append("Findings:")
+    if report.findings:
+        for finding in report.findings:
+            lines.append(f"- {finding.level.upper()}: {finding.title} - {finding.detail}")
+    else:
+        lines.append("- No blocking findings.")
+    lines.append("")
+    lines.append("Action items:")
+    for item in report.action_items:
+        lines.append(f"- {item}")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def format_json(report: ReleaseNoteReport) -> str:
+    return json.dumps(report.to_dict(), indent=2) + "\n"
+
+
+def format_html(report: ReleaseNoteReport) -> str:
+    finding_cards = "\n".join(
+        f"<li class='{html.escape(f.level)}'><strong>{html.escape(f.level.upper())}: {html.escape(f.title)}</strong><p>{html.escape(f.detail)}</p></li>"
+        for f in report.findings
+    ) or "<li>No blocking findings.</li>"
+    sections = "\n".join(
+        f"<section><h3>{html.escape(section.name.title())}</h3><ul>{''.join(f'<li>{html.escape(item)}</li>' for item in section.items)}</ul></section>"
+        for section in report.sections
+    )
+    actions = "".join(f"<li>{html.escape(item)}</li>" for item in report.action_items)
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Release Note Readiness</title>
+  <style>
+    body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 0; color: #17202a; background: #f7f8fb; }}
+    main {{ max-width: 980px; margin: 0 auto; padding: 32px 20px; }}
+    .hero {{ background: #ffffff; border: 1px solid #d9e0ea; border-radius: 8px; padding: 24px; }}
+    .score {{ font-size: 44px; font-weight: 750; margin: 0; }}
+    .status {{ display: inline-block; margin-top: 8px; padding: 5px 10px; border-radius: 6px; background: #e7f0ff; }}
+    li {{ margin: 8px 0; }}
+    .high strong {{ color: #9f1d1d; }}
+    .medium strong {{ color: #8a5a00; }}
+    section, .panel {{ background: #ffffff; border: 1px solid #d9e0ea; border-radius: 8px; margin-top: 16px; padding: 18px; }}
+  </style>
+</head>
+<body>
+  <main>
+    <div class="hero">
+      <p class="score">{report.score}/100</p>
+      <span class="status">{html.escape(report.readiness)}</span>
+      <p>{html.escape(report.summary)}</p>
+    </div>
+    <div class="panel"><h2>Findings</h2><ul>{finding_cards}</ul></div>
+    <div class="panel"><h2>Action Items</h2><ul>{actions}</ul></div>
+    <h2>Parsed Sections</h2>
+    {sections}
+  </main>
+</body>
+</html>
+"""
+
+
+def _parse_sections(text: str) -> tuple[Section, ...]:
+    current = "uncategorized"
+    buckets: dict[str, list[str]] = {current: []}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        heading = re.sub(r"^#+\s*", "", line).strip(" :")
+        heading_key = SECTION_ALIASES.get(heading.lower())
+        if heading_key and (raw_line.lstrip().startswith("#") or not re.match(r"^[-*]\s+", line)):
+            current = heading_key
+            buckets.setdefault(current, [])
+            continue
+        item = re.sub(r"^[-*]\s+|\d+[.)]\s+", "", line).strip()
+        if item:
+            category = current if current != "uncategorized" else _classify_item(item)
+            buckets.setdefault(category, []).append(item)
+    return tuple(Section(name, tuple(values)) for name, values in buckets.items() if values)
+
+
+def _classify_item(item: str) -> str:
+    lower = item.lower()
+    for category, keywords in CATEGORY_KEYWORDS.items():
+        if any(keyword in lower for keyword in keywords):
+            return category
+    return "uncategorized"
+
+
+def _contains_any(text: str, terms: Iterable[str]) -> bool:
+    lower = text.lower()
+    return any(term in lower for term in terms)
+
+
+def _has_section(sections: Iterable[Section], name: str) -> bool:
+    return any(section.name == name and section.items for section in sections)
+
+
+def _has_any_release_category(sections: tuple[Section, ...], items: list[str]) -> bool:
+    known = {"added", "fixed", "changed", "breaking", "security", "deprecated"}
+    return any(section.name in known for section in sections) or any(_classify_item(item) in known for item in items)
+
+
+def _is_vague(item: str) -> bool:
+    lower = item.lower()
+    if len(item.split()) <= 4:
+        return True
+    return any(phrase in lower for phrase in ("various fixes", "minor updates", "improvements", "misc cleanup", "better stuff"))
+
+
+def _score(findings: tuple[Finding, ...] | list[Finding], sections: tuple[Section, ...], items: list[str], has_customer: bool, has_validation: bool, has_rollback: bool) -> int:
+    score = 100
+    for finding in findings:
+        score -= 22 if finding.level == "high" else 11 if finding.level == "medium" else 5
+    if len(sections) >= 3:
+        score += 4
+    if len(items) >= 5:
+        score += 4
+    if has_customer:
+        score += 4
+    if has_validation:
+        score += 4
+    if has_rollback:
+        score += 3
+    if any(finding.level == "high" for finding in findings):
+        score = min(score, 64)
+    return max(0, min(100, score))
+
+
+def _action_items(findings: tuple[Finding, ...] | list[Finding]) -> tuple[str, ...]:
+    if not findings:
+        return ("Publish after final owner review.",)
+    mapping = {
+        "Customer impact missing": "Add a customer-impact sentence for every high-risk change.",
+        "Migration notes missing": "Write upgrade, compatibility, or migration steps for breaking changes.",
+        "Validation evidence missing": "Add test, rollout, staging, or monitoring evidence.",
+        "Rollback note missing": "Document rollback, revert, or feature-flag controls.",
+        "Draft placeholders remain": "Replace placeholders with final release details.",
+        "Vague entries": "Rewrite vague bullets into specific shipped behavior.",
+        "No recognizable release categories": "Group entries under standard release note headings.",
+        "Very thin draft": "Add concrete bullets for the main changes.",
+        "No release notes supplied": "Add release note content.",
+    }
+    return tuple(dict.fromkeys(mapping.get(finding.title, finding.detail) for finding in findings))
+
+
+def _summary(score: int, readiness: str, sections: tuple[Section, ...], findings: tuple[Finding, ...]) -> str:
+    section_names = ", ".join(section.name for section in sections) or "no sections"
+    if not findings:
+        return f"The draft is {readiness} with clear coverage across {section_names}."
+    high_count = sum(1 for finding in findings if finding.level == "high")
+    return f"The draft scored {score}/100 across {section_names}; {high_count} high-risk gap(s) need attention."

release_note_readiness_desk-0.1.0/src/release_note_readiness/desktop.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from pathlib import Path
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+
+from .core import analyze_notes, format_markdown
+
+
+SAMPLE = """# Added
+- Added workspace-level export for audit admins.
+
+# Changed
+- Changed invoice webhook payload defaults for developers.
+
+# Breaking
+- Removed legacy invoice.status values from the public API.
+"""
+
+
+class ReleaseNoteApp(tk.Tk):
+    def __init__(self) -> None:
+        super().__init__()
+        self.title("Release Note Readiness")
+        self.geometry("1120x720")
+        self.minsize(880, 560)
+        self._build()
+        self.input.insert("1.0", SAMPLE)
+        self.run_check()
+
+    def _build(self) -> None:
+        self.columnconfigure(0, weight=1)
+        self.columnconfigure(1, weight=1)
+        self.rowconfigure(1, weight=1)
+
+        toolbar = ttk.Frame(self, padding=(10, 8))
+        toolbar.grid(row=0, column=0, columnspan=2, sticky="ew")
+        ttk.Button(toolbar, text="Open", command=self.open_file).pack(side="left")
+        ttk.Button(toolbar, text="Check", command=self.run_check).pack(side="left", padx=6)
+        ttk.Button(toolbar, text="Copy Report", command=self.copy_report).pack(side="left")
+        ttk.Button(toolbar, text="Save Report", command=self.save_report).pack(side="left", padx=6)
+        self.status = ttk.Label(toolbar, text="")
+        self.status.pack(side="right")
+
+        left = ttk.Frame(self, padding=(10, 0, 5, 10))
+        left.grid(row=1, column=0, sticky="nsew")
+        left.rowconfigure(1, weight=1)
+        left.columnconfigure(0, weight=1)
+        ttk.Label(left, text="Draft").grid(row=0, column=0, sticky="w")
+        self.input = tk.Text(left, wrap="word", undo=True)
+        self.input.grid(row=1, column=0, sticky="nsew")
+
+        right = ttk.Frame(self, padding=(5, 0, 10, 10))
+        right.grid(row=1, column=1, sticky="nsew")
+        right.rowconfigure(1, weight=1)
+        right.columnconfigure(0, weight=1)
+        ttk.Label(right, text="Readiness Report").grid(row=0, column=0, sticky="w")
+        self.output = tk.Text(right, wrap="word")
+        self.output.grid(row=1, column=0, sticky="nsew")
+
+    def open_file(self) -> None:
+        path = filedialog.askopenfilename(filetypes=[("Text files", "*.md *.txt"), ("All files", "*.*")])
+        if not path:
+            return
+        self.input.delete("1.0", "end")
+        self.input.insert("1.0", Path(path).read_text(encoding="utf-8"))
+        self.run_check()
+
+    def run_check(self) -> None:
+        report = analyze_notes(self.input.get("1.0", "end"))
+        rendered = format_markdown(report)
+        self.output.delete("1.0", "end")
+        self.output.insert("1.0", rendered)
+        self.status.config(text=f"{report.score}/100 - {report.readiness}")
+
+    def copy_report(self) -> None:
+        self.clipboard_clear()
+        self.clipboard_append(self.output.get("1.0", "end").strip())
+        self.status.config(text="Copied report")
+
+    def save_report(self) -> None:
+        path = filedialog.asksaveasfilename(defaultextension=".md", filetypes=[("Markdown", "*.md"), ("Text", "*.txt")])
+        if not path:
+            return
+        Path(path).write_text(self.output.get("1.0", "end"), encoding="utf-8")
+        messagebox.showinfo("Saved", f"Report saved to {path}")
+
+
+def main() -> None:
+    app = ReleaseNoteApp()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()
+

release_note_readiness_desk-0.1.0/src/release_note_readiness_desk.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: release-note-readiness-desk
+Version: 0.1.0
+Summary: Local CLI and desktop checker for release note readiness gaps
+Author: Haider Sattar
+License-Expression: MIT
+Keywords: release-notes,changelog,product,qa,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+![Release Note Readiness desktop preview](docs/screenshot.svg)
+
+# Release Note Readiness Desk
+
+Release Note Readiness Desk checks changelog drafts, PR summaries, and release-note copy for gaps that usually cause avoidable release confusion: missing migration steps, unclear customer impact, vague bullets, unresolved placeholders, absent validation evidence, and missing rollback notes.
+
+It runs locally as a CLI or a small Tkinter desktop app. There are no runtime dependencies.
+
+## Install
+
+```bash
+python3 -m pip install release-note-readiness-desk
+```
+
+## CLI
+
+```bash
+release-note-readiness examples/release-draft.md
+release-note-readiness examples/release-draft.md --format html --output readiness.html
+release-note-readiness CHANGELOG.md --fail-under 80 --fail-on-high
+```
+
+Read from stdin:
+
+```bash
+cat CHANGELOG.md | release-note-readiness --format json
+```
+
+## Desktop App
+
+```bash
+release-note-readiness-gui
+```
+
+Paste a draft, click **Check**, then copy or save the Markdown report.
+
+## What It Checks
+
+- Breaking or high-risk changes without migration guidance
+- Risky changes without customer impact language
+- Missing validation or rollout evidence
+- Missing rollback, revert, or feature-flag notes
+- Draft placeholders such as `TODO` or `TBD`
+- Vague entries like "minor updates" or "various fixes"
+- Missing standard release-note categories
+
+## Development
+
+```bash
+python3 -m unittest discover -s tests
+python3 -m build --no-isolation
+python3 -m twine check dist/*
+```
+
+## License
+
+MIT

release_note_readiness_desk-0.1.0/src/release_note_readiness_desk.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+docs/screenshot.svg
+examples/release-draft.md
+src/release_note_readiness/__init__.py
+src/release_note_readiness/cli.py
+src/release_note_readiness/core.py
+src/release_note_readiness/desktop.py
+src/release_note_readiness_desk.egg-info/PKG-INFO
+src/release_note_readiness_desk.egg-info/SOURCES.txt
+src/release_note_readiness_desk.egg-info/dependency_links.txt
+src/release_note_readiness_desk.egg-info/entry_points.txt
+src/release_note_readiness_desk.egg-info/top_level.txt
+tests/test_core.py

release_note_readiness_desk-0.1.0/src/release_note_readiness_desk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

release_note_readiness_desk-0.1.0/src/release_note_readiness_desk.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+release-note-readiness = release_note_readiness.cli:main
+release-note-readiness-gui = release_note_readiness.desktop:main

release_note_readiness_desk-0.1.0/src/release_note_readiness_desk.egg-info/top_level.txt

@@ -0,0 +1 @@
+release_note_readiness

release_note_readiness_desk-0.1.0/tests/test_core.py

@@ -0,0 +1,52 @@
+import unittest
+
+from release_note_readiness.core import analyze_notes, format_json, format_markdown
+
+
+class CoreTests(unittest.TestCase):
+    def test_ready_release_notes_score_well(self) -> None:
+        report = analyze_notes(
+            """
+            # Added
+            - Added project usage export for customer admins.
+            # Breaking
+            - Removed legacy invoice.status values from the public API.
+            # Migration
+            - Developers should map pending_payment to open before upgrading.
+            # Validation
+            - Verified in staging with webhook replay tests.
+            # Rollback
+            - Disable invoice_webhook_v2 to restore old payloads.
+            """
+        )
+
+        self.assertGreaterEqual(report.score, 85)
+        self.assertEqual(report.readiness, "ready")
+        self.assertFalse(any(finding.level == "high" for finding in report.findings))
+
+    def test_flags_missing_migration_for_breaking_change(self) -> None:
+        report = analyze_notes(
+            """
+            # Changed
+            - Removed old API response fields.
+            - Minor updates.
+            """
+        )
+
+        titles = {finding.title for finding in report.findings}
+        self.assertIn("Migration notes missing", titles)
+        self.assertIn("Customer impact missing", titles)
+        self.assertEqual(report.readiness, "blocked")
+        self.assertLessEqual(report.score, 64)
+
+    def test_formats_include_score_and_findings(self) -> None:
+        report = analyze_notes("- TODO add final release notes")
+
+        self.assertIn('"score"', format_json(report))
+        markdown = format_markdown(report)
+        self.assertIn("Release Note Readiness", markdown)
+        self.assertIn("Draft placeholders remain", markdown)
+
+
+if __name__ == "__main__":
+    unittest.main()