alissa-tools-github-orcloop 0.3.6__tar.gz → 0.3.7__tar.gz

{alissa_tools_github_orcloop-0.3.6/src/main/alissa_tools_github_orcloop.egg-info → alissa_tools_github_orcloop-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-orcloop
-Version: 0.3.6
+Version: 0.3.7
 Summary: ALISSA-TOOLS-GITHUB-ORCLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_orcloop-0.3.6 → alissa_tools_github_orcloop-0.3.7}/src/main/alissa/tools/github/orcloop/loop.py

@@ -262,7 +262,13 @@ from .alissa_client import (
 )
 from .config import FEED_BOW, Config
 from .ghclient import GitHub, Issue, PullRequest, RateLimited, parse_task_ref
-from .markers import is_bow_feed, parse_bow_repo, parse_marker, parse_scope
+from .markers import (
+    find_mid_line_trailer,
+    is_bow_feed,
+    parse_bow_repo,
+    parse_marker,
+    parse_scope,
+)
 from .proc import CommandError
 from .state import State
 
@@ -497,6 +503,18 @@ DEGRADED_DISCOVERY_REASON = (
     "— held rather than released to a possibly-wrong repo; retries next poll"
 )
 
+# The one wording every missed-trailer warning uses (O13, issue #32). Appended
+# to a reason or a warning that was ALREADY going to be emitted, never a line of
+# its own: a missed trailer is not a new condition, it is the likeliest
+# EXPLANATION of a degradation the operator is already reading about. It states
+# the anchoring rule because that rule is the fix -- the operator does not have
+# to read the parser to learn why their text was ignored.
+MALFORMED_TRAILER_NOTE = (
+    "NOTE: `{key}:` found mid-line — malformed trailer? {fragment!r} (a "
+    "trailer is only read at the START of its own line, so that text was "
+    "ignored)"
+)
+
 SWEEP_INVISIBLE_REASON = (
     "carries the release marker but is attached to no {prefix!r} body of work "
     "— the bow feed will never release it (attachment is the only trigger); "
@@ -640,6 +658,24 @@ class Orchestrator:
         log.log(level, "%s → %s (%s)", slug, decision.action.value, decision.reason)
         return (slug, decision)
 
+    def _malformed_trailer(self, text: str, key: str) -> str:
+        """The `; NOTE: ...` suffix naming trailer-like text the anchored parser
+        ignored -- empty string when there is nothing to name (the usual case).
+
+        Ask this ONLY where the anchored parse has already answered "absent",
+        and only for the suffix: the detector behind it is lenient by design
+        (case-insensitive, fires on prose) and its answer may never reach a
+        decision, a dedupe or a lane. Every caller computes it once per subject
+        per pass and appends it to a line it was already emitting, which is what
+        keeps the no-new-spam-channel rule true.
+
+        The `key` is passed in by the caller from `Config`, so a deployment that
+        renamed its trailers gets warnings about ITS names, not the defaults."""
+        fragment = find_mid_line_trailer(text, key)
+        if fragment is None:
+            return ""
+        return "; " + MALFORMED_TRAILER_NOTE.format(key=key, fragment=fragment)
+
     # -- escalation --------------------------------------------------------
 
     def _escalate(
@@ -710,6 +746,24 @@ class Orchestrator:
         ):
             issue = self.github.issue(owner, repo, number)
             scope = parse_scope(issue.body, self.config.scope_key)
+            if not scope:
+                # This issue is about to occupy its repo's WHOLE lane, which is
+                # the right reading of a scopeless body and the wrong one of a
+                # malformed trailer -- and the two are indistinguishable in
+                # every later line, because from here on the lane only carries
+                # `[]`. Said once per issue per pass, here, where the difference
+                # is still visible. (A released body keeps the operator's prose
+                # verbatim, mid-line fragment and all: `_strip_control_lines`
+                # drops trailers by the same anchored rule, so what was missed
+                # in the task is missed in the issue too.)
+                note = self._malformed_trailer(issue.body, self.config.scope_key)
+                if note:
+                    log.warning(
+                        "%s declares no `%s:` trailer, so it occupies the WHOLE "
+                        "%s lane%s",
+                        issue.issue_slug, self.config.scope_key,
+                        issue.full_name, note,
+                    )
             occupancy.setdefault(issue.full_name, []).append(scope)
             task_number = parse_task_ref(issue.body)
             if task_number is None:
@@ -1457,11 +1511,21 @@ class Orchestrator:
         if target is None:
             marker = parse_marker(task.description, self.config.marker_key)
             if marker is None or not self.config.watches(marker):
-                reason = (
-                    f"no valid `{self.config.marker_key}: <owner>/<repo>` trailer"
-                    if marker is None
-                    else f"target {marker} is not in the watched repos allowlist"
-                )
+                if marker is None:
+                    # The commonest way to reach `unreleasable` by accident: the
+                    # trailer IS there, just not at the start of a line. The
+                    # page and the log line both carry the reason, so extending
+                    # it here is what puts the suspect text in front of the
+                    # operator on the one channel this condition has.
+                    reason = (
+                        f"no valid `{self.config.marker_key}: <owner>/<repo>` "
+                        f"trailer"
+                        + self._malformed_trailer(
+                            task.description, self.config.marker_key
+                        )
+                    )
+                else:
+                    reason = f"target {marker} is not in the watched repos allowlist"
                 self._escalate(
                     task.task_number,
                     ESCALATION_UNRELEASABLE,
@@ -1491,13 +1555,24 @@ class Orchestrator:
             return self._release_blocked(task)
 
         scope = parse_scope(task.description, self.config.scope_key)
+        # A missed scope trailer is never neutral: scopeless means "occupies the
+        # whole lane", so it both HOLDS this candidate behind any occupant and,
+        # once released, holds everything else behind it. Both outcomes are
+        # decided right below, and both are worth explaining -- so the note is
+        # computed once here, on the task body, and carried into whichever line
+        # this candidate produces.
+        note = "" if scope else self._malformed_trailer(
+            task.description, self.config.scope_key
+        )
         lane_reason = self._lane_blocked(target, scope, occupancy)
         if lane_reason is not None:
             return self._logged(task.ref, Decision(
-                Action.HELD, f"lane {target} occupied: {lane_reason}", task.task_number,
+                Action.HELD,
+                f"lane {target} occupied: {lane_reason}{note}",
+                task.task_number,
             ))
 
-        return self._release(task, target, scope, occupancy, bow=bow)
+        return self._release(task, target, scope, occupancy, bow=bow, note=note)
 
     def _release_blocked(self, task: Task) -> tuple[str, Decision]:
         """The dependency gate holds. Below the floor this is a quiet per-poll
@@ -1720,6 +1795,23 @@ class Orchestrator:
             )
 
         issue_scope = parse_scope(issue.body, self.config.scope_key)
+        # Same read and same degradation as `_scan_released`, on a body a human
+        # wrote by hand -- the likeliest place of all for a trailer to sit in a
+        # sentence. Computed once and appended to each of the four exits that
+        # REPORT A LANE (hold, dry-run, adopt, already-labeled skip), so the
+        # pass never carries the same note twice.
+        #
+        # The fifth exit -- the `except` below, where the adoption itself failed
+        # -- deliberately does not carry it: its story is the exception, and it
+        # is not the recurring line it looks like. That branch wraps
+        # `record_release` AND `add_label`, so its common shape (row written,
+        # label call failed) leaves a `labeled=0` row, and the next pass routes
+        # to `_dedupe_result`'s crash-recovery branch rather than back here.
+        # What recurs in the malformed-trailer case is the lane hold above,
+        # which does carry it.
+        issue_note = "" if issue_scope else self._malformed_trailer(
+            issue.body, self.config.scope_key
+        )
         labeled = self.config.label in issue.labels
         if not labeled:
             lane_reason = self._lane_blocked(target, issue_scope, occupancy)
@@ -1742,7 +1834,7 @@ class Orchestrator:
                     f"cannot adopt {issue.issue_slug} yet: lane {target} "
                     f"occupied: {lane_reason} — the issue declares "
                     f"{issue_scope or '(scopeless — needs an empty lane)'}, "
-                    f"whatever the task declares; retries next poll",
+                    f"whatever the task declares; retries next poll{issue_note}",
                     task.task_number,
                 ))
 
@@ -1769,7 +1861,7 @@ class Orchestrator:
                 Action.SKIPPED if labeled else Action.RELEASED,
                 f"[dry-run] {verb} pre-existing {issue.issue_slug} (carries "
                 f"this task's `Alissa-Task:` trailer{unlabeled_note})"
-                f"{in_flight}{self._detach(task.ref, bow)}",
+                f"{in_flight}{self._detach(task.ref, bow)}{issue_note}",
                 task.task_number,
             ))
 
@@ -1796,7 +1888,7 @@ class Orchestrator:
                     f"already released by hand as {issue.issue_slug} (trailer "
                     f"and {self.config.label!r} label present); recorded in the "
                     f"ledger, no second issue{in_flight}"
-                    f"{self._detach(task.ref, bow)}",
+                    f"{self._detach(task.ref, bow)}{issue_note}",
                     task.task_number,
                 ))
             self.github.add_label(issue.owner, issue.repo, issue.number, self.config.label)
@@ -1819,7 +1911,7 @@ class Orchestrator:
             f"adopted pre-existing {issue.issue_slug} (carries this task's "
             f"trailer, was unlabeled): ledger row recorded and "
             f"{self.config.label!r} applied{in_flight}"
-            f"{self._detach(task.ref, bow)}",
+            f"{self._detach(task.ref, bow)}{issue_note}",
             task.task_number,
         ))
 
@@ -1999,6 +2091,7 @@ class Orchestrator:
         occupancy: dict[str, list[list[str]]],
         *,
         bow: BodyOfWork | None = None,
+        note: str = "",
     ) -> tuple[str, Decision]:
         """Create the issue (unlabeled), record the ledger row, stamp the label,
         move the origin task `committed → in_progress`, then -- under the `bow`
@@ -2011,7 +2104,15 @@ class Orchestrator:
 
         Nothing is created until the TRAILER dedupe answers: the pass-level
         scan is label-scoped and cannot see an unlabeled issue that already
-        carries this task's trailer (see `_trailer_dedupe`)."""
+        carries this task's trailer (see `_trailer_dedupe`).
+
+        `note` is the caller's missed-trailer warning (empty unless this is a
+        SCOPELESS release with trailer-like text in the body). It rides on the
+        release line rather than being logged separately, because that line is
+        the record of a task taking the whole lane -- possibly on the strength
+        of a trailer nobody parsed. It is passed in rather than recomputed so
+        one candidate can never produce two of them; the dedupe path returns
+        above with its own note, computed on the ISSUE body it acts on."""
         owner, _, repo = target.partition("/")
         preexisting = self._trailer_dedupe(task, target, occupancy, bow=bow)
         if preexisting is not None:
@@ -2026,7 +2127,7 @@ class Orchestrator:
                 Action.RELEASED,
                 f"[dry-run] would release to {target} "
                 f"(label {self.config.label!r}){in_flight}"
-                f"{self._detach(task.ref, bow)}",
+                f"{self._detach(task.ref, bow)}{note}",
                 task.task_number,
             ))
 
@@ -2053,7 +2154,7 @@ class Orchestrator:
         return self._logged(task.ref, Decision(
             Action.RELEASED,
             f"released to {issue.issue_slug}{in_flight}"
-            f"{self._detach(task.ref, bow)}",
+            f"{self._detach(task.ref, bow)}{note}",
             task.task_number,
         ))
 

{alissa_tools_github_orcloop-0.3.6 → alissa_tools_github_orcloop-0.3.7}/src/main/alissa/tools/github/orcloop/markers.py

@@ -35,6 +35,17 @@ IS the repo declaration. `Autonomous-Scope` still comes from the task body. The
 owner/repo shape is validated with the same strictness as the trailer, so a
 mistyped BOW title reads as "no repo" (→ `unreleasable`) rather than silently
 targeting something unexpected.
+
+O13 adds `find_mid_line_trailer`, which is deliberately NOT one of the parsers
+above: it is a LENIENT detector whose only output is a warning. The anchoring
+rule is correct and stays, but its failure mode is silent — a trailer written at
+the end of a paragraph reads as absent, and "absent" is a meaningful answer
+everywhere the loop asks (a scopeless task occupies a whole lane; a task with no
+`Autonomous-Dev` is unreleasable). The detector exists so those degradations can
+NAME the text they ignored. Its answer must never feed a decision: it fires on
+prose (`see Autonomous-Scope: x for the format`) by design, because judging
+intent is the operator's job and a false positive in a log line costs nothing
+while a false positive in a release decision cannot be taken back.
 """
 
 from __future__ import annotations
@@ -52,6 +63,23 @@ _SCOPE_TEMPLATE = r"^{key}:[ \t]*(.*?)\s*$"
 # Scope items are separated by commas and/or any run of whitespace.
 _SCOPE_SPLIT = re.compile(r"[,\s]+")
 
+# The lenient detector (O13). `(?!^)` is the whole point: under MULTILINE, `^`
+# matches at the start of every line, so refusing it leaves EXACTLY the
+# positions the anchored parsers cannot see -- mid-sentence, and after an indent
+# (`   Autonomous-Scope: src/**` is not a trailer either, and is the same
+# mistake). The key is matched case-insensitively via a scoped inline flag, so
+# an operator-typed `autonomous-scope:` is caught without loosening anything
+# else. `[ \t]*\S` requires CONTENT after the colon: a bare `... Autonomous-Dev:`
+# ending a sentence declares nothing, so it is not evidence of a lost
+# declaration and reporting it would be noise.
+_MID_LINE_TEMPLATE = r"(?!^)(?i:{key}):[ \t]*\S"
+
+# How much of the offending line the warning quotes. The fragment goes into log
+# lines and escalation comments that already carry a reason, so it is a pointer
+# ("here is the text I ignored"), not the body -- enough to find with a search,
+# short enough to keep one decision on one line.
+MID_LINE_FRAGMENT_LIMIT = 80
+
 # The whole BOW title after its prefix must be exactly one owner/repo — the same
 # shape the `Autonomous-Dev` trailer accepts, anchored to the whole remainder so
 # a title like `autodev: acme/widgets (paused)` does NOT parse as a feed.
@@ -90,6 +118,37 @@ def parse_scope(text: str, scope_key: str = "Autonomous-Scope") -> list[str]:
     return [glob for glob in _SCOPE_SPLIT.split(match.group(1).strip()) if glob]
 
 
+@lru_cache(maxsize=None)
+def _mid_line_re(key: str) -> re.Pattern[str]:
+    return re.compile(_MID_LINE_TEMPLATE.format(key=re.escape(key)), re.MULTILINE)
+
+
+def find_mid_line_trailer(
+    text: str, key: str, *, limit: int = MID_LINE_FRAGMENT_LIMIT
+) -> str | None:
+    """A quotable fragment of the first `<key>:` written MID-LINE, or None.
+
+    Warning input only -- see the module docstring. Callers must ask this only
+    where the anchored parser already answered "absent", and must never let the
+    answer change what they do; `None` means "nothing here looks like a missed
+    trailer", not "no trailer".
+
+    The fragment starts at the key (what the operator has to go and fix), stops
+    at the end of that line (a decision line stays one line), and is truncated
+    to `limit` characters so a wall of prose cannot swamp the reason it is
+    appended to.
+    """
+    match = _mid_line_re(key).search(text)
+    if match is None:
+        return None
+    line_end = text.find("\n", match.start())
+    end = len(text) if line_end < 0 else line_end
+    fragment = text[match.start():end].strip()
+    if len(fragment) > limit:
+        fragment = fragment[:limit].rstrip() + "..."
+    return fragment
+
+
 def is_bow_feed(title: str, prefix: str) -> bool:
     """Whether a Body of Work's title claims to be a release feed.
 

alissa_tools_github_orcloop-0.3.7/src/main/alissa/tools/github/orcloop/version

@@ -0,0 +1 @@
+0.3.7

{alissa_tools_github_orcloop-0.3.6 → alissa_tools_github_orcloop-0.3.7/src/main/alissa_tools_github_orcloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-orcloop
-Version: 0.3.6
+Version: 0.3.7
 Summary: ALISSA-TOOLS-GITHUB-ORCLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_orcloop-0.3.6/src/main/alissa/tools/github/orcloop/version

@@ -1 +0,0 @@
-0.3.6