rylees 0.1.0__py3-none-any.whl

app/.env.example

@@ -0,0 +1,12 @@
+# Required
+#RYLEES_API_URL=http://api.rylees.test/v1
+RYLEES_API_URL=https://api.rylees.ai/v1
+RYLEES_API_TOKEN=
+RYLEES_PROJECT_TOKEN=
+OPENAI_API_KEY=
+
+# Optional — overrides the temperature fetched from the API
+# RYLEES_LLM_TEMPERATURE=0.5
+
+# Optional — overrides the default model
+RYLEES_LLM_MODEL=GPT-5.4

app/api_client.py

@@ -0,0 +1,40 @@
+import httpx
+from app.models import ProjectConfig, PublishPayload, PublishResponse
+
+BASE_URL = "https://api.rylees.ai/v1"
+
+class ApiClient:
+    def __init__(self, api_token: str, base_url: str = BASE_URL):
+        self._client = httpx.Client(
+            base_url=base_url,
+            headers={"Authorization": f"Bearer {api_token}"},
+            timeout=30.0,
+        )
+
+    def get_project(self, project_token: str) -> ProjectConfig:
+        response = self._client.get(f"/projects/{project_token}")
+        response.raise_for_status()
+        data = response.json()
+        return ProjectConfig(
+            id=data["id"],
+            name=data["name"],
+            key=data["key"],
+            description=data.get("description", ""),
+            customer_name=data["customer"]["name"],
+            customer_industry=data["customer"]["industry"],
+            llm_temperature=data["llm"]["temperature"],
+            llm_tonality=data["llm"]["tonality"],
+        )
+
+    def publish_release_note(
+        self, project_token: str, payload: PublishPayload
+    ) -> PublishResponse:
+        response = self._client.post(
+            f"/projects/{project_token}/release-history",
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def close(self):
+        self._client.close()

app/cli.py

@@ -0,0 +1,509 @@
+import os
+import sys
+import time
+import shutil
+import textwrap
+import itertools
+import threading
+import tempfile
+import subprocess
+from contextlib import contextmanager
+from typing import Annotated
+import typer
+
+app = typer.Typer(name="rylees")
+
+SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+@contextmanager
+def _spinner(message: str):
+    """Animate a braille spinner on stderr while a slow task runs.
+
+    Writes to stderr so the generated draft on stdout stays clean and
+    pipeable. Renders nothing when stderr isn't a TTY (e.g. CI logs).
+    """
+    if not sys.stderr.isatty():
+        yield
+        return
+
+    done = threading.Event()
+
+    def spin():
+        for frame in itertools.cycle(SPINNER_FRAMES):
+            if done.is_set():
+                break
+
+            sys.stderr.write(f"\r{frame} {message}")
+            sys.stderr.flush()
+            time.sleep(0.08)
+
+    thread = threading.Thread(target=spin, daemon=True)
+    thread.start()
+    try:
+        yield
+    finally:
+        done.set()
+        thread.join()
+        # Clear the spinner line so it leaves no residue behind.
+        sys.stderr.write("\r\033[K")
+        sys.stderr.flush()
+
+
+class Checklist:
+    """A live, multi-line task checklist rendered on stderr.
+
+    Each step shows a grey tick while pending, a round spinner while active,
+    and a green tick once done (red cross on failure). On a non-TTY (CI logs,
+    piped output) it degrades to one plain line per completed/failed step.
+    """
+
+    PENDING, ACTIVE, DONE, FAIL = "pending", "active", "done", "fail"
+
+    GREY, GREEN, RED, CYAN, RESET = (
+        "\033[90m", "\033[32m", "\033[31m", "\033[36m", "\033[0m",
+    )
+    ROUND_FRAMES = "◐◓◑◒"
+
+    def __init__(self, labels: list[str]):
+        self._labels = list(labels)
+        self._states = [self.PENDING] * len(labels)
+        self._enabled = sys.stderr.isatty()
+        self._frame = 0
+        self._lock = threading.Lock()
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._drawn = False
+
+    def _glyph(self, i: int) -> str:
+        state = self._states[i]
+        if state == self.DONE:
+            return f"{self.GREEN}✓{self.RESET}"
+        if state == self.FAIL:
+            return f"{self.RED}✗{self.RESET}"
+        if state == self.ACTIVE:
+            frame = self.ROUND_FRAMES[self._frame % len(self.ROUND_FRAMES)]
+            return f"{self.CYAN}{frame}{self.RESET}"
+        return f"{self.GREY}✓{self.RESET}"  # pending — grey tick
+
+    def _render(self) -> None:
+        out = []
+        if self._drawn:
+            out.append(f"\033[{len(self._labels)}A")  # cursor up to block top
+        for i, label in enumerate(self._labels):
+            out.append(f"\r\033[K  {self._glyph(i)} {label}\n")
+        sys.stderr.write("".join(out))
+        sys.stderr.flush()
+        self._drawn = True
+
+    def _animate(self) -> None:
+        while not self._stop.is_set():
+            with self._lock:
+                self._frame += 1
+                self._render()
+            time.sleep(0.12)
+
+    def _ensure_thread(self) -> None:
+        if self._thread is None:
+            self._stop.clear()
+            self._thread = threading.Thread(target=self._animate, daemon=True)
+            self._thread.start()
+
+    def _halt_thread(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join()
+            self._thread = None
+
+    def begin(self) -> None:
+        """Draw the full checklist (all steps pending) and start animating."""
+        if not self._enabled:
+            return
+        with self._lock:
+            self._render()
+        self._ensure_thread()
+
+    def active(self, i: int) -> None:
+        if not self._enabled:
+            return
+        with self._lock:
+            self._states[i] = self.ACTIVE
+            if not self._drawn:
+                self._render()
+        self._ensure_thread()
+
+    def done(self, i: int) -> None:
+        if not self._enabled:
+            sys.stderr.write(f"  ✓ {self._labels[i]}\n")
+            sys.stderr.flush()
+            return
+        with self._lock:
+            self._states[i] = self.DONE
+            self._render()
+
+    def fail(self, i: int) -> None:
+        if not self._enabled:
+            sys.stderr.write(f"  ✗ {self._labels[i]}\n")
+            sys.stderr.flush()
+            return
+        self._halt_thread()
+        with self._lock:
+            self._states[i] = self.FAIL
+            self._render()
+        sys.stderr.write("\n")
+        sys.stderr.flush()
+
+    def pause(self) -> None:
+        """Freeze the current block so other output can print below it."""
+        if not self._enabled:
+            return
+        self._halt_thread()
+        with self._lock:
+            self._render()
+        sys.stderr.write("\n")
+        sys.stderr.flush()
+
+    def resume(self) -> None:
+        """Re-draw the checklist fresh at the cursor (after paused output)."""
+        if not self._enabled:
+            return
+        self._drawn = False
+        with self._lock:
+            self._render()
+        self._ensure_thread()
+
+    def stop(self) -> None:
+        self._halt_thread()
+        if self._enabled:
+            with self._lock:
+                self._render()
+
+
+def _scrub(message: str, *secrets: str) -> str:
+    """Redact secrets (tokens/keys) that error messages may echo back.
+
+    httpx embeds the request URL in its error strings, and the project token
+    travels in that URL — so a failed API call would otherwise leak it to
+    stderr/CI logs.
+    """
+    for secret in secrets:
+        if secret:
+            message = message.replace(secret, "***")
+    return message
+
+
+def _render_box(text: str, actions: str | None = None) -> None:
+    """Print text inside a heavy-bordered (bold) box.
+
+    Has spacing outside the box (blank line above/below) and inside the box
+    (padding around the text). Long lines wrap to the terminal width. When
+    ``actions`` is given it is embedded into the bottom border line.
+    """
+    PAD_X = 3
+    term_width = shutil.get_terminal_size((80, 24)).columns
+    inner_width = max(24, min(76, term_width - 2 - PAD_X * 2))
+
+    wrapped: list[str] = []
+    for paragraph in text.splitlines() or [""]:
+        if paragraph.strip() == "":
+            wrapped.append("")
+        else:
+            wrapped.extend(textwrap.wrap(paragraph, width=inner_width) or [""])
+
+    width = max((len(line) for line in wrapped), default=0)
+    span = width + PAD_X * 2
+    if actions is not None:
+        span = max(span, len(actions) + 6)  # room for "━━ <actions> ━…"
+        width = span - PAD_X * 2            # keep content lines aligned
+
+    blank = "┃" + " " * span + "┃"
+    if actions is not None:
+        fill = span - len(actions) - 4     # 2 leading ━, a space each side
+        bottom = "┗━━ " + actions + " " + "━" * max(fill, 0) + "┛"
+    else:
+        bottom = "┗" + "━" * span + "┛"
+
+    print()                              # spacing outside the box (top)
+    print("┏" + "━" * span + "┓")
+    print(blank)                         # spacing inside the box (top)
+    for line in wrapped:
+        print("┃" + " " * PAD_X + line.ljust(width) + " " * PAD_X + "┃")
+    print(blank)                         # spacing inside the box (bottom)
+    print(bottom)
+    print()                              # spacing outside the box (bottom)
+
+
+def _read_key() -> str:
+    """Read a single keypress (lowercased), no Enter required.
+
+    Uses cbreak mode so the key is captured immediately while Ctrl-C still
+    raises. Falls back to line-based reading when stdin isn't a TTY (tests,
+    pipes).
+    """
+    if not sys.stdin.isatty():
+        return sys.stdin.readline().strip().lower()[:1]
+
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        ch = sys.stdin.read(1)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    return ch.lower()
+
+
+def _display_draft(draft: str) -> None:
+    _render_box(draft, actions="[A] Accept   [R] Regenerate   [E] Edit   [C] Cancel")
+
+
+def _open_in_editor(text: str) -> str:
+    editor = os.environ.get("EDITOR", "nano")
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".txt", delete=False, encoding="utf-8"
+    ) as f:
+        f.write(text)
+        tmp_path = f.name
+    subprocess.call([editor, tmp_path])
+    with open(tmp_path, encoding="utf-8") as f:
+        edited = f.read()
+    os.unlink(tmp_path)
+    return edited
+
+
+def _run_generate(
+    start: str,
+    end: str,
+    type_: str,
+    major: bool,
+    minor: bool,
+    patch: bool,
+    publish: bool,
+) -> None:
+    from app.config import Config, ConfigError
+    from app.api_client import ApiClient
+    from app.git_connector import GitConnector, GitConnectorError
+    from app.code_analyzer import CodeAnalyzer
+    from app.release_notes_generator import ReleaseNotesGenerator, GenerationError
+    from app.rn_publisher import RNPublisher
+
+    # Version bump mutual exclusivity
+    bump_count = sum([major, minor, patch])
+    if bump_count > 1:
+        typer.echo("Error: only one of --major, --minor, --patch may be set at a time.", err=True)
+        raise typer.Exit(code=1)
+    if bump_count == 0:
+        minor = True
+
+    if major:
+        version_bump = "major"
+    elif patch:
+        version_bump = "patch"
+    else:
+        version_bump = "minor"
+
+    # --type validation
+    if type_ not in ("tag", "commit"):
+        typer.echo("Error: --type must be 'tag' or 'commit'.", err=True)
+        raise typer.Exit(code=1)
+    ref_type_api = "tag" if type_ == "tag" else "commits"
+
+    # Step 1 — Load config
+    try:
+        config = Config.load()
+    except ConfigError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1)
+
+    # Step 2 — Fetch project config from API
+    api_client = ApiClient(api_token=config.api_token, base_url=config.api_url)
+    try:
+        project = api_client.get_project(config.project_token)
+    except Exception as e:
+        msg = _scrub(str(e), config.project_token, config.api_token)
+        typer.echo(f"Failed to fetch project config: {msg}", err=True)
+        raise typer.Exit(code=1)
+
+    # Step 3 — Apply temperature override if set
+    temperature = (
+        config.llm_temperature_override
+        if config.llm_temperature_override is not None
+        else project["llm_temperature"]
+    )
+
+    # Step 4 — Open Git repository (need the branch name for the checklist label)
+    try:
+        connector = GitConnector()
+        branch = connector.current_branch()
+    except GitConnectorError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1)
+
+    checklist = Checklist([
+        f"Diffing from {type_} {start} from {branch} branch",
+        "LLM generates release note",
+        "Publishing to project",
+    ])
+    checklist.begin()
+
+    # Step 4 (cont.) — Compute diff + Step 5 — Analyze (strip noise, truncate)
+    checklist.active(0)
+    try:
+        commits, diff = connector.get_diff(start, end, type_)
+        analysis = CodeAnalyzer().analyze(commits, diff)
+    except GitConnectorError as e:
+        checklist.fail(0)
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1)
+    checklist.done(0)
+
+    # Step 6 — Generate release note draft
+    checklist.active(1)
+    try:
+        generator = ReleaseNotesGenerator(model=config.llm_model, temperature=temperature)
+        draft = generator.generate(analysis, project)
+    except GenerationError as e:
+        checklist.fail(1)
+        typer.echo(str(e), err=True)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        checklist.fail(1)
+        msg = _scrub(str(e), config.openai_api_key, config.project_token, config.api_token)
+        typer.echo(f"Release note generation failed: {msg}", err=True)
+        raise typer.Exit(code=1)
+    checklist.done(1)
+
+    publisher = RNPublisher(api_client, config.project_token)
+
+    def _publish(body: str):
+        checklist.active(2)
+        try:
+            result = publisher.publish(
+                body=body,
+                version_bump=version_bump,
+                start_ref=start,
+                end_ref=end,
+                ref_type=ref_type_api,
+            )
+        except Exception as e:
+            checklist.fail(2)
+            msg = _scrub(str(e), config.project_token, config.api_token)
+            typer.echo(f"Publish failed: {msg}", err=True)
+            raise typer.Exit(code=1)
+        checklist.done(2)
+        checklist.stop()
+        typer.echo(f"Published: {result['status']} — version {result['version']}")
+
+    # Freeze the checklist so the generated note prints in its box below it.
+    checklist.pause()
+
+    # Step 7 — --publish bypass (no HITL): all three steps run back-to-back
+    if publish:
+        _render_box(draft)
+        typer.echo(
+            "⚠  Publishing release note without human review (--publish flag active).",
+            err=True,
+        )
+        checklist.resume()
+        _publish(draft)
+        return
+
+    # Step 8–13 — Interactive HITL loop. _display_draft renders the note box;
+    # the publishing step resumes the checklist on accept.
+    current_draft = draft
+    while True:
+        _display_draft(current_draft)
+
+        # Wait for a single, valid keypress (no Enter needed).
+        while True:
+            choice = _read_key()
+            if choice in ("a", "r", "e", "c"):
+                break
+            if choice in ("", "q", "\x03", "\x04"):  # EOF / quit / Ctrl-C / Ctrl-D
+                typer.echo("Nothing published.", err=True)
+                raise typer.Exit(code=1)
+
+        if choice == "c":
+            # Cancel — quit immediately without publishing
+            typer.echo("Nothing published.")
+            raise typer.Exit(code=0)
+
+        if choice == "a":
+            # Accept and publish
+            checklist.resume()
+            _publish(current_draft)
+            return
+
+        elif choice == "r":
+            # Regenerate from same analysis
+            try:
+                with _spinner("Regenerating release note…"):
+                    current_draft = generator.generate(analysis, project)
+            except GenerationError as e:
+                typer.echo(str(e), err=True)
+                raise typer.Exit(code=1)
+            except Exception as e:
+                msg = _scrub(str(e), config.openai_api_key, config.project_token, config.api_token)
+                typer.echo(f"Release note generation failed: {msg}", err=True)
+                raise typer.Exit(code=1)
+
+        elif choice == "e":
+            # Open in editor
+            current_draft = _open_in_editor(current_draft)
+
+
+@app.command(name="generate")
+def generate(
+    start: Annotated[str, typer.Option("--start", "-s", help="Start tag or commit hash")] = ...,
+    end: Annotated[str, typer.Option("--end", "-e", help="End tag or commit hash")] = "HEAD",
+    type_: Annotated[str, typer.Option("--type", "-t", help="'tag' or 'commit'")] = "tag",
+    major: Annotated[bool, typer.Option("--major", help="Bump major version")] = False,
+    minor: Annotated[bool, typer.Option("--minor", help="Bump minor version")] = False,
+    patch: Annotated[bool, typer.Option("--patch", help="Bump patch version")] = False,
+    publish: Annotated[bool, typer.Option("--publish", "-p", help="Skip HITL and publish immediately")] = False,
+):
+    _run_generate(start, end, type_, major, minor, patch, publish)
+
+
+@app.command(name="gen", hidden=True)
+def gen(
+    start: Annotated[str, typer.Option("--start", "-s", help="Start tag or commit hash")] = ...,
+    end: Annotated[str, typer.Option("--end", "-e", help="End tag or commit hash")] = "HEAD",
+    type_: Annotated[str, typer.Option("--type", "-t", help="'tag' or 'commit'")] = "tag",
+    major: Annotated[bool, typer.Option("--major", help="Bump major version")] = False,
+    minor: Annotated[bool, typer.Option("--minor", help="Bump minor version")] = False,
+    patch: Annotated[bool, typer.Option("--patch", help="Bump patch version")] = False,
+    publish: Annotated[bool, typer.Option("--publish", "-p", help="Skip HITL and publish immediately")] = False,
+):
+    _run_generate(start, end, type_, major, minor, patch, publish)
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo("rylees 0.1.0")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool,
+        typer.Option("--version", "-V", callback=version_callback, is_eager=True),
+    ] = False,
+):
+    # Called without a subcommand: show the `generate` help (the primary command).
+    if ctx.invoked_subcommand is None:
+        generate_cmd = ctx.command.get_command(ctx, "generate")
+        with typer.Context(
+            generate_cmd, info_name="generate", parent=ctx
+        ) as sub_ctx:
+            typer.echo(generate_cmd.get_help(sub_ctx))
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

app/code_analyzer.py

@@ -0,0 +1,46 @@
+import re
+from app.models import AnalysisResult
+
+EXCLUDED_FILE_PATTERNS = re.compile(
+    r"^diff --git a/(.*\.lock|package-lock\.json|yarn\.lock|.*\.min\.js|.*\.min\.css)\b",
+    re.MULTILINE,
+)
+
+class CodeAnalyzer:
+    MAX_WORDS = int(8000 / 1.3)  # ≈ 6153 words ≈ 8000 tokens
+
+    def analyze(self, commits: list, diff: str) -> AnalysisResult:
+        cleaned = self._strip_excluded(diff)
+        cleaned = self._strip_binary(cleaned)
+        cleaned = self._truncate(cleaned)
+        messages = [c.message.strip() for c in commits]
+        return AnalysisResult(diff=cleaned, commit_messages=messages)
+
+    def _strip_excluded(self, diff: str) -> str:
+        # Split on "diff --git" boundaries and discard excluded files
+        hunks = re.split(r"(?=^diff --git )", diff, flags=re.MULTILINE)
+        kept = []
+        for hunk in hunks:
+            if not hunk:
+                continue
+            if EXCLUDED_FILE_PATTERNS.match(hunk):
+                continue
+            kept.append(hunk)
+        return "".join(kept)
+
+    def _strip_binary(self, diff: str) -> str:
+        hunks = re.split(r"(?=^diff --git )", diff, flags=re.MULTILINE)
+        kept = []
+        for hunk in hunks:
+            if not hunk:
+                continue
+            if "Binary files" in hunk:
+                continue
+            kept.append(hunk)
+        return "".join(kept)
+
+    def _truncate(self, diff: str) -> str:
+        words = diff.split()
+        if len(words) <= self.MAX_WORDS:
+            return diff
+        return " ".join(words[: self.MAX_WORDS]) + "\n...[truncated]"

app/config.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from dotenv import find_dotenv, load_dotenv
+import os
+
+from app.api_client import BASE_URL as DEFAULT_API_URL
+
+class ConfigError(Exception):
+    def __init__(self, var_name: str):
+        self.var_name = var_name
+        super().__init__(f"Missing required configuration variable: {var_name}")
+
+@dataclass
+class Config:
+    api_token: str
+    project_token: str
+    openai_api_key: str
+    api_url: str
+    llm_model: str
+    llm_temperature_override: float | None
+
+    @classmethod
+    def load(cls) -> "Config":
+        # Load .env from the current working directory (the target project), not
+        # from the rylees source tree. usecwd=True makes find_dotenv search up
+        # from the cwd instead of from this file's location.
+        load_dotenv(find_dotenv(usecwd=True))
+        required = {
+            "RYLEES_API_TOKEN": None,
+            "RYLEES_PROJECT_TOKEN": None,
+            "OPENAI_API_KEY": None,
+        }
+        for var in required:
+            val = os.getenv(var)
+            if not val:
+                raise ConfigError(var)
+            required[var] = val
+
+        temp_override = os.getenv("RYLEES_LLM_TEMPERATURE")
+        return cls(
+            api_token=required["RYLEES_API_TOKEN"],
+            project_token=required["RYLEES_PROJECT_TOKEN"],
+            openai_api_key=required["OPENAI_API_KEY"],
+            api_url=os.getenv("RYLEES_API_URL", DEFAULT_API_URL),
+            llm_model=os.getenv("RYLEES_LLM_MODEL", "GPT-5.4"),
+            llm_temperature_override=float(temp_override) if temp_override else None,
+        )

app/git_connector.py

@@ -0,0 +1,40 @@
+from typing import Literal
+import git
+from app.models import AnalysisResult
+
+class GitConnectorError(Exception):
+    pass
+
+class GitConnector:
+    def __init__(self, repo_path: str = "."):
+        try:
+            self._repo = git.Repo(repo_path)
+        except git.InvalidGitRepositoryError:
+            raise GitConnectorError(f"Not a valid git repository: {repo_path}")
+
+    def current_branch(self) -> str:
+        """Return the active branch name, or the short HEAD sha when detached."""
+        try:
+            return self._repo.active_branch.name
+        except TypeError:
+            return self._repo.head.commit.hexsha[:7]
+
+    def get_diff(
+        self,
+        start_ref: str,
+        end_ref: str,
+        ref_type: Literal["tag", "commit"],
+    ) -> tuple[list[git.Commit], str]:
+        try:
+            if ref_type == "tag":
+                start = self._repo.tags[start_ref].commit
+                end = self._repo.tags[end_ref].commit if end_ref != "HEAD" else self._repo.head.commit
+            else:
+                start = self._repo.commit(start_ref)
+                end = self._repo.commit(end_ref) if end_ref != "HEAD" else self._repo.head.commit
+        except (IndexError, git.BadName, KeyError, ValueError):
+            raise GitConnectorError(f"Reference not found: check --start and --end values")
+
+        commits = list(self._repo.iter_commits(f"{start.hexsha}..{end.hexsha}"))
+        diff_str = self._repo.git.diff(start.hexsha, end.hexsha)
+        return commits, diff_str

app/models.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import TypedDict, Literal
+
+class ProjectConfig(TypedDict):
+    id: str
+    name: str
+    key: str
+    description: str
+    customer_name: str
+    customer_industry: str
+    llm_temperature: float
+    llm_tonality: str
+
+@dataclass
+class AnalysisResult:
+    diff: str
+    commit_messages: list[str]
+
+class PublishPayload(TypedDict):
+    startRef: str
+    endRef: str
+    type: Literal["commits", "tag"]
+    branchName: str
+    body: str
+    versionBump: Literal["major", "minor", "patch"]
+
+class PublishResponse(TypedDict):
+    id: str
+    status: str
+    version: str

app/release_notes_generator.py

@@ -0,0 +1,67 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from app.models import AnalysisResult, ProjectConfig
+from app.validator import Validator, ValidationError
+
+class GenerationError(Exception):
+    pass
+
+SYSTEM_PROMPT_TEMPLATE = """\
+You are a technical writer creating release notes for {customer_name},
+a company in the {customer_industry} industry.
+
+Your task is to summarise the following code changes in one short,
+{tonality} paragraph written for a non-technical audience.
+
+Rules:
+- Do NOT mention file names, function names, or code.
+- Do NOT use technical jargon.
+- Write in German.
+- Maximum 500 words.
+- Describe what changed from the user's perspective, not how it was implemented.\
+"""
+
+USER_PROMPT_TEMPLATE = """\
+Project: {project_description}
+
+Commit messages:
+{commit_messages}
+
+Code diff summary:
+{diff}\
+"""
+
+class ReleaseNotesGenerator:
+    MAX_RETRIES = 3
+
+    def __init__(self, model: str, temperature: float):
+        self._llm = ChatOpenAI(model=model, temperature=temperature)
+        self._validator = Validator()
+
+    def generate(self, analysis: AnalysisResult, project: ProjectConfig) -> str:
+        system_content = SYSTEM_PROMPT_TEMPLATE.format(
+            customer_name=project["customer_name"],
+            customer_industry=project["customer_industry"],
+            tonality=project["llm_tonality"],
+        )
+        user_content = USER_PROMPT_TEMPLATE.format(
+            project_description=project["description"],
+            commit_messages="\n".join(analysis.commit_messages),
+            diff=analysis.diff,
+        )
+        for attempt in range(self.MAX_RETRIES):
+            messages = [
+                SystemMessage(content=system_content),
+                HumanMessage(content=user_content),
+            ]
+            response = self._llm.invoke(messages)
+            draft = response.content
+            try:
+                self._validator.validate(draft)
+                return draft
+            except ValidationError:
+                if attempt == self.MAX_RETRIES - 1:
+                    raise GenerationError(
+                        f"LLM output failed validation after {self.MAX_RETRIES} attempts"
+                    )
+        raise GenerationError("Unreachable")

app/rn_publisher.py

@@ -0,0 +1,27 @@
+from typing import Literal
+from app.api_client import ApiClient
+from app.models import PublishPayload, PublishResponse
+
+class RNPublisher:
+    def __init__(self, api_client: ApiClient, project_token: str):
+        self._client = api_client
+        self._project_token = project_token
+
+    def publish(
+        self,
+        body: str,
+        version_bump: Literal["major", "minor", "patch"],
+        start_ref: str,
+        end_ref: str,
+        ref_type: Literal["commits", "tag"],
+        branch_name: str | None = None,
+    ) -> PublishResponse:
+        payload: PublishPayload = {
+            "startRef": start_ref,
+            "endRef": end_ref,
+            "type": ref_type,
+            "branchName": branch_name or "",
+            "body": body,
+            "versionBump": version_bump,
+        }
+        return self._client.publish_release_note(self._project_token, payload)

app/validator.py

@@ -0,0 +1,12 @@
+class ValidationError(Exception):
+    pass
+
+class Validator:
+    def validate(self, text: str) -> None:
+        stripped = text.strip()
+        if not stripped:
+            raise ValidationError("Response is empty or whitespace")
+        if len(stripped) < 10:
+            raise ValidationError("Response too short (min 10 chars)")
+        if len(stripped) > 2000:
+            raise ValidationError("Response too long (max 2000 chars)")

rylees-0.1.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: rylees
+Version: 0.1.0
+Summary: LLM-assisted release note generator and publisher
+Project-URL: Repository, https://github.com/zihmm/rylees
+Author-email: Marc Zimmerli <marc@uniqode.ch>
+License-Expression: MIT
+Keywords: cli,git,llm,release-notes
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: gitpython>=3.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-openai>=0.2
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest-httpx>=0.30; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Rylees CLI
+
+An LLM-assisted release-note generator and publisher. `rylees` reads the diff
+between two points in your Git history, asks an LLM to draft a release note in
+your project's configured tone, lets you review or edit it, and publishes it to
+the Rylees backend.
+
+## Requirements
+
+- Python **3.12** or newer
+- A Git repository to generate notes from
+- A Rylees API token and project token (from the developer console)
+- An OpenAI API key
+
+## Installation
+
+The CLI is a standard PEP 517 package. Install it from the `src/cli` directory.
+
+### Using a virtual environment (recommended)
+
+```bash
+cd src/cli
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install .
+```
+
+For development, install in editable mode with the dev dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Using uv
+
+```bash
+cd src/cli
+uv venv
+uv pip install -e ".[dev]"
+```
+
+Once installed, the `rylees` command is available on your `PATH` (inside the
+activated environment):
+
+```bash
+rylees --version
+```
+
+## Configuration
+
+`rylees` reads configuration from a `.env` file in your **current working
+directory** (it searches upward from the cwd, not from the CLI's install
+location). Copy the bundled example and fill in your values:
+
+```bash
+cp .env.example .env
+```
+
+| Variable | Required | Description |
+| --- | --- | --- |
+| `RYLEES_API_TOKEN` | yes | Authenticates you against the Rylees API. |
+| `RYLEES_PROJECT_TOKEN` | yes | Identifies the project to publish notes to. |
+| `OPENAI_API_KEY` | yes | Used by the LLM to draft the release note. |
+| `RYLEES_API_URL` | no | Override the base API URL. Default: `https://api.rylees.ai/v1`. |
+| `RYLEES_LLM_TEMPERATURE` | no | Override the temperature configured on the project. |
+| `RYLEES_LLM_MODEL` | no | Override the model. Default: `GPT-5.4`. |
+
+If a required variable is missing, the CLI exits with an error naming the
+variable.
+
+## Usage
+
+Run `rylees` from the root of the Git repository you want to generate notes for.
+
+```bash
+rylees generate --start <ref> [options]
+```
+
+### Options
+
+| Option | Alias | Default | Description |
+| --- | --- | --- | --- |
+| `--start` | `-s` | *(required)* | Start tag or commit hash. |
+| `--end` | `-e` | `HEAD` | End tag or commit hash. |
+| `--type` | `-t` | `tag` | Reference type: `tag` or `commit`. |
+| `--major` | | | Bump the major version. |
+| `--minor` | | (default) | Bump the minor version. |
+| `--patch` | | | Bump the patch version. |
+| `--publish` | `-p` | off | Skip the review step and publish immediately. |
+
+Only one of `--major`, `--minor`, `--patch` may be set. If none is given,
+`--minor` is assumed.
+
+### Examples
+
+Generate a note for the changes between two tags and review it interactively:
+
+```bash
+rylees generate --start v1.2.0 --end v1.3.0 --minor
+```
+
+Generate from a range of commits instead of tags:
+
+```bash
+rylees generate --type commit --start a1b2c3d --end HEAD
+```
+
+Generate and publish a major release without manual review (use with care —
+this skips human review and prints a warning to stderr):
+
+```bash
+rylees generate --start v1.0.0 --major --publish
+```
+
+### Interactive review (HITL)
+
+Without `--publish`, the CLI prints the generated draft and prompts for an
+action:
+
+```
+[A] Accept and publish   [R] Regenerate     [E] Edit
+```
+
+- **A** — publish the current draft to the Rylees backend.
+- **R** — regenerate a fresh draft from the same diff.
+- **E** — open the draft in your editor (`$EDITOR`, default `nano`), then return
+  to the prompt with your edits.
+
+On a successful publish, the CLI prints the resulting status and version.
+
+## How it works
+
+1. Loads and validates configuration from `.env`.
+2. Fetches the project's configuration (tone, temperature) from the Rylees API.
+3. Opens the local Git repository and computes the diff between `--start` and
+   `--end`.
+4. Strips noise (binary and lock-file diffs) and truncates the diff to fit the
+   LLM context window.
+5. Generates a release-note draft in the project's configured tonality.
+6. Lets you review, regenerate, or edit the draft — then publishes it.
+
+## Development
+
+Run the test suite from `src/cli`:
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

rylees-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/api_client.py,sha256=i0l9y-K3zSHLCsKkqIgPee6pSBO1YjKzcFC5jwOd1tI,1333
+app/cli.py,sha256=OMPUL0Zun5BJFaUpFotHW0Lia4MB-haxc1u-XruLf_I,17028
+app/code_analyzer.py,sha256=N5r1gNb9xFVY0wUDAimXtnw0V3Yd7VKl5pBKSsmpHNE,1578
+app/config.py,sha256=si_21lHtNZiGJ9JQiryHzcZo4bsjo4GX0-r90pquIwI,1593
+app/git_connector.py,sha256=Oax3BnFBsVSMjdBJo5bM6-wV_-grGQ6qAXr47DuAOy0,1509
+app/models.py,sha256=Aqc0kdMQXaOp4tC7tejHR_kYdOJ3_xxnsRiR3Clx_2U,613
+app/release_notes_generator.py,sha256=vwzYyX7DGoVVECVTSj4DnDZ1CBuHuCeIng7R1Am7fWw,2275
+app/rn_publisher.py,sha256=2nDxjMFyWIEKldu1_0YfUN-J1Qf_PFWiyDEne4hving,883
+app/validator.py,sha256=ruUlwcMS_6iRvx1qXVLNsI1eI4F0n2PdFmIEyLUaOPc,437
+app/.env.example,sha256=019FsNFq6TMGRoFK1LgrqWdYtGWYKoEEirDTqRgYLH0,309
+rylees-0.1.0.dist-info/METADATA,sha256=iHAwjLWSJt268pJU0oaAfz6OL73TCOcP4l_L_ayJ110,4919
+rylees-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+rylees-0.1.0.dist-info/entry_points.txt,sha256=LETpo6YzvTSvquDulgx4fi7U2hKHSHK1K24Bt3CkR8g,39
+rylees-0.1.0.dist-info/RECORD,,

rylees-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

rylees-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rylees = app.cli:app