alissa-tools-github-orcloop 0.3.4__tar.gz → 0.3.5__tar.gz

{alissa_tools_github_orcloop-0.3.4/src/main/alissa_tools_github_orcloop.egg-info → alissa_tools_github_orcloop-0.3.5}/PKG-INFO

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

{alissa_tools_github_orcloop-0.3.4 → alissa_tools_github_orcloop-0.3.5}/src/main/alissa/tools/github/orcloop/__main__.py

@@ -126,7 +126,9 @@ def build_parser() -> argparse.ArgumentParser:
         action="append",
         metavar="ACTOR_ID",
         help="bow feed only: trust bodies of work OWNED by this Alissa actor "
-        "as release feeds; repeatable. When given, REPLACES the config "
+        "as release feeds; repeatable, and one flag may carry several ids "
+        "separated by `|` (the daemon-family convention) or `,`, the same as "
+        "--repo. When given, REPLACES the config "
         "`bow_owners` list. OPTIONAL — left unset, the daemon resolves its own "
         "token's actor at boot and trusts only its own containers; give this "
         "flag only when the containers belong to someone else. Being SHARED a "

{alissa_tools_github_orcloop-0.3.4 → alissa_tools_github_orcloop-0.3.5}/src/main/alissa/tools/github/orcloop/config.py

@@ -21,19 +21,36 @@ watch nothing, but boot anyway), an empty orcloop allowlist is **fatal at
 startup** — the orchestrator releases work into `alissa:develop` issues and
 closes the loop on merge, so it never runs against an unbounded repo set.
 
-REPOS SEPARATOR (O7). A repo list written as one string — `ALISSA_ORC_REPOS`,
-a `--repo a/b|c/d` flag, or a single-element list in the config file — is split
-on **both `|` and `,`**, mixed freely. `|` is the daemon **family convention**
-(devloop's `ALISSA_DEV_REPOS` has always been pipe-separated); comma stays
-accepted for backward compatibility with every orcloop release up to 0.3.0.
-The convention matters because the operator points several Railway services at
-ONE list through a variable reference — `ALISSA_ORC_REPOS=${{dev.ALISSA_DEV_REPOS}}`
-— which only works if both daemons read the same separator. Entries are
-whitespace-stripped, empties from splitting are dropped (so a trailing
-separator is harmless), duplicates collapse, and each surviving entry must look
-like `owner/repo` (a bare word or a pasted URL is a fatal startup error naming
-the offending entry). An allowlist that is empty *after* parsing stays fatal —
-fail-closed is unchanged.
+LIST SEPARATORS (O7, O11). **Every** list-valued key parses the same way. A
+list written as one string — `ALISSA_ORC_REPOS`, `ALISSA_ORC_BOW_OWNERS`, a
+`--repo a/b|c/d` flag, or a single element of the config file's list — is split
+on **both `|` and `,`**, mixed freely, by the one shared splitter
+(`split_entries`). `|` is the daemon **family convention** (devloop's
+`ALISSA_DEV_REPOS` has always been pipe-separated); comma stays accepted for
+backward compatibility with every orcloop release up to 0.3.0. The convention
+matters because the operator points several Railway services at ONE list
+through a variable reference —
+`ALISSA_ORC_REPOS=${{dev.ALISSA_DEV_REPOS}}` — which only works if both daemons
+read the same separator. Entries are whitespace-stripped, empties from
+splitting are dropped (so a trailing separator is harmless), and duplicates
+collapse.
+
+What differs per key is the SHAPE check and what an empty result means — never
+the syntax:
+
+* `repos` entries must look like `owner/repo` (a bare word or a pasted URL is a
+  fatal startup error naming the offending entry), and an allowlist that is
+  empty *after* parsing stays fatal — fail-closed is unchanged.
+* `bow_owners` entries must look like an Alissa actor id (see below), and an
+  empty result means "not overridden", not "trust everyone" (see FEED
+  AUTHORITY).
+
+That the two keys once disagreed is the defect O11 closed: through 0.3.4
+`bow_owners` split on `,` only, so an operator following the documented
+convention got a single entry containing a `|`. Since 0.3.2's shape check that
+at least aborted startup, but phrased as though a username had been typed;
+before it, the entry simply matched no actor and the fail-closed feed released
+nothing at all. Both are why the splitter is shared rather than copied.
 
 The marker contract (`Autonomous-Dev` / `Autonomous-Scope` issue-body
 trailers) is parsed in `markers.py`; the keys that name those trailers live
@@ -119,17 +136,17 @@ RELEASE_FEEDS = (FEED_SCAN, FEED_BOW)
 # Keys carrying a boolean; env strings for these need real parsing (bool("false")
 # is True, which would silently invert the setting).
 _BOOL_KEYS = frozenset({"dry_run", "close_loop_enabled"})
-# Keys carrying a list of strings. In an env value they are separator-delimited;
-# `repos` accepts the family's `|` as well as `,` (see REPO_SEPARATORS), every
-# other list key is comma-separated.
+# Keys carrying a list of strings. Every one of them is separator-delimited when
+# it arrives as a single string, with the SAME separators (see LIST_SEPARATORS
+# and `split_entries`) — a per-key syntax is exactly the drift O11 removed.
 _LIST_KEYS = frozenset({"repos", "bow_owners"})
 
-# The separators a one-string repo list may use, in preference order. `|` is the
-# daemon-family convention (devloop's ALISSA_DEV_REPOS), which is what lets one
-# Railway variable reference feed both daemons; `,` is what orcloop shipped
+# The separators any one-string list value may use, in preference order. `|` is
+# the daemon-family convention (devloop's ALISSA_DEV_REPOS), which is what lets
+# one Railway variable reference feed both daemons; `,` is what orcloop shipped
 # through 0.3.0 and stays accepted. Mixing them in one value is fine.
-REPO_SEPARATORS = ("|", ",")
-_REPO_SPLIT_RE = re.compile("[" + re.escape("".join(REPO_SEPARATORS)) + "]")
+LIST_SEPARATORS = ("|", ",")
+_LIST_SPLIT_RE = re.compile("[" + re.escape("".join(LIST_SEPARATORS)) + "]")
 
 # What an allowlist entry must look like once split: exactly one `/`, a GitHub
 # owner (alphanumerics and hyphens, not leading/trailing) and a repo name
@@ -205,19 +222,41 @@ def _string_list(value: Any, key: str) -> tuple[str, ...]:
     return tuple(value)
 
 
-def split_repo_entries(raw: str) -> list[str]:
-    """Split one repo-list string into entries on `|` and/or `,`.
+def split_entries(raw: str) -> list[str]:
+    """Split one list-valued string into entries on `|` and/or `,`.
 
     Whitespace around an entry is stripped and empties are dropped, so a
     trailing separator, a doubled one, and `a/b | c/d` all behave. This is the
-    ONE place the separator set is applied: the library's env layer, the CLI
-    flag, the config file, and the container's `render_config.py` all route
-    through it, so no surface can end up accepting a different syntax.
-
-    Splitting only — shape validation is `normalize_repos`, because the config
-    file may also hand over an already-split JSON list.
+    ONE place the separator set is applied, for EVERY list key: the library's
+    env layer, the CLI flags, the config file, and the container's
+    `render_config.py` all route through it, so neither a surface nor a key can
+    end up accepting a different syntax (through 0.3.4 `bow_owners` did — see
+    the module docstring).
+
+    Splitting only — the per-key shape check is `normalize_repos` /
+    `normalize_bow_owners`, because the config file may also hand over an
+    already-split JSON list.
     """
-    return [entry for part in _REPO_SPLIT_RE.split(raw) if (entry := part.strip())]
+    return [entry for part in _LIST_SPLIT_RE.split(raw) if (entry := part.strip())]
+
+
+# The 0.3.1-0.3.4 name, kept as an alias rather than deleted. The container's
+# `render_config.py` resolves the splitter through `getattr(cfg, ...)` so that a
+# dist too OLD to carry it dies naming it; an image built from an older
+# docker/claude directory against a NEWER dist would hit that same branch on a
+# pure rename and be told its library is too old, which is both false and the
+# opposite of the fix. One line keeps that message honest. New code uses
+# `split_entries`; there is no second implementation to drift.
+#
+# `REPO_SEPARATORS` — the constant renamed in the same release — deliberately
+# gets NO alias, because the two names fail differently. The function is
+# resolved dynamically, so a missing one produces a MISDIRECTING message; the
+# constant was never resolved at runtime by any shipped renderer (0.3.1-0.3.4
+# only name it in a comment), so a stale import of it is an ImportError naming
+# the symbol — loud and self-explanatory. There is no lie for an alias to
+# prevent there, and a `REPO_*` name for a list-neutral concept would invite the
+# next reader straight back into the drift this release closed.
+split_repo_entries = split_entries
 
 
 def normalize_repos(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
@@ -236,7 +275,7 @@ def normalize_repos(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
     out: list[str] = []
     seen: set[str] = set()
     for value in values:
-        for entry in split_repo_entries(value):
+        for entry in split_entries(value):
             _validate_repo_entry(entry)
             if (key := entry.casefold()) not in seen:
                 seen.add(key)
@@ -288,11 +327,14 @@ def _validate_repo_entry(entry: str) -> None:
 def normalize_bow_owners(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
     """Turn the raw `bow_owners` layer value into the validated authority list.
 
-    Entries are whitespace-stripped, empties dropped (so a trailing comma is
-    harmless, matching `repos`), duplicates collapsed — EXACTLY, with no
-    casefolding, because actor ids are opaque: two spellings that differ in case
-    are two different strings on the wire, and folding them would silently widen
-    the match. Every survivor must look like an actor id.
+    Parsed EXACTLY like `repos`, through the same `split_entries`: an element
+    may itself carry a whole `|`- and/or `,`-separated list (that is what
+    `ALISSA_ORC_BOW_OWNERS` and a Railway variable reference look like),
+    whitespace is stripped and empties dropped, so a trailing separator is
+    harmless. Duplicates collapse EXACTLY, with no casefolding — unlike `repos`,
+    because actor ids are opaque: two spellings that differ in case are two
+    different strings on the wire, and folding them would silently widen the
+    match. Every survivor must look like an actor id.
 
     Emptiness is fine here and means "not overridden": the boot path resolves
     the authority to this token's own actor (see the module docstring). There is
@@ -303,13 +345,11 @@ def normalize_bow_owners(values: tuple[str, ...] | list[str]) -> tuple[str, ...]
     out: list[str] = []
     seen: set[str] = set()
     for value in values:
-        entry = value.strip()
-        if not entry:
-            continue
-        _validate_actor_id(entry)
-        if entry not in seen:
-            seen.add(entry)
-            out.append(entry)
+        for entry in split_entries(value):
+            _validate_actor_id(entry)
+            if entry not in seen:
+                seen.add(entry)
+                out.append(entry)
     return tuple(out)
 
 
@@ -353,7 +393,18 @@ def _validate_actor_id(entry: str) -> None:
                 f"it contains {offending!r}, which no actor id does"
             )
         hint = " — " + " and ".join(problems)
-        if offending:
+        parts = entry.split()
+        if len(parts) > 1 and all(_ACTOR_ID_RE.match(part) for part in parts):
+            # Splitting has already run, so an entry that STILL holds whitespace
+            # was never separated at all. Say so ONLY when every part is itself
+            # an id, which is the only evidence that this is two ids and not a
+            # display name: "Alissa Code PR Review" also contains spaces, and
+            # telling its author to fix their separator loses the hint below —
+            # the diagnostic O8 added, in the change that is about diagnostics.
+            # A mixed `<id> not-an-id` falls through here on purpose: that
+            # operator's problem is the entry, not the separator.
+            hint += "; separate several ids with `|` or `,`, not a space"
+        elif offending:
             hint += "; that looks like a username or a display name"
     raise ValueError(
         f"bow_owners entry {entry!r} is not an Alissa actor id{hint}. Use the "
@@ -362,8 +413,9 @@ def _validate_actor_id(entry: str) -> None:
         f"username or display name: names are renameable, so an ownership "
         f"check against one is a spoof surface, and since no id on the wire "
         f"ever equals a name it would fail as a silently empty feed rather "
-        f"than an error. Leave bow_owners unset to trust this token's own "
-        f"actor, which needs no id at all."
+        f"than an error. Several ids are separated by `|` (the daemon-family "
+        f"convention) or `,`, the same as repos. Leave bow_owners unset to "
+        f"trust this token's own actor, which needs no id at all."
     )
 
 
@@ -397,15 +449,13 @@ def env_overrides(environ: Mapping[str, str] | None = None) -> dict[str, Any]:
         raw = env[env_name]
         if key in _BOOL_KEYS:
             out[key] = _env_bool(env_name, raw)
-        elif key == "repos":
-            # Separator-tolerant (`|` and `,`); shape-validated in `build`
-            # alongside the file and CLI layers, so one bad entry reports the
-            # same way wherever it came from.
-            out[key] = tuple(split_repo_entries(raw))
         elif key in _LIST_KEYS:
-            out[key] = tuple(
-                item for part in raw.split(",") if (item := part.strip())
-            )
+            # ONE branch for every list key, separator-tolerant (`|` and `,`).
+            # `repos` had its own until 0.3.4 while the rest split on `,` alone,
+            # which is precisely how the two syntaxes drifted apart. Shape is
+            # validated in `build` alongside the file and CLI layers, so one bad
+            # entry reports the same way wherever it came from.
+            out[key] = tuple(split_entries(raw))
         else:
             out[key] = raw
     return out
@@ -465,8 +515,11 @@ class Config:
     # allowed to OWN a feed container. The title tells the daemon which repo a
     # container targets; it says nothing about who created it, and the daemon
     # lists containers it merely collaborates on, which anyone in the tenant can
-    # arrange unilaterally. So provenance is decided here. Ids are opaque and
-    # compared EXACTLY (unlike `repos`, which casefolds GitHub names).
+    # arrange unilaterally. So provenance is decided here. Entries reach `build`
+    # as `|`- and/or `,`-separated text from any layer, exactly like `repos`, and
+    # land here split, shape-checked and de-duplicated — but de-duplicated
+    # EXACTLY: ids are opaque, so unlike `repos` (case-insensitive GitHub names)
+    # nothing here is casefolded, in the comparison or in the collapse.
     #
     # Empty means "not overridden", NOT "trust everyone": the boot path resolves
     # it to this token's own actor and dies if it cannot (O8), and until it does

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

@@ -0,0 +1 @@
+0.3.5

{alissa_tools_github_orcloop-0.3.4 → alissa_tools_github_orcloop-0.3.5/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.4
+Version: 0.3.5
 Summary: ALISSA-TOOLS-GITHUB-ORCLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.3.4