foundry-implementation-actor 0.6.0__tar.gz → 0.7.0__tar.gz

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: foundry-implementation-actor
-Version: 0.6.0
+Version: 0.7.0
 Summary: Runs a headless Claude Code implementation session against one capability's own repo — a papeete-actor for one use, with the capability supplied by a sidecar.
 Project-URL: Homepage, https://github.com/papeete-hub/foundry-implementation-actor
 Author-email: Papeete Consulting <yoann.remy@outlook.com>

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foundry-implementation-actor"
-version = "0.6.0"
+version = "0.7.0"
 description = "Runs a headless Claude Code implementation session against one capability's own repo — a papeete-actor for one use, with the capability supplied by a sidecar."
 readme = "README.md"
 requires-python = ">=3.11"

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/src/foundry_implementation_actor/config.py

@@ -12,7 +12,7 @@ They are now derivations of two fields. Nothing in this package spells a capabil
     capability   ACME.PARTS.CAP.SUP.007.WID                   ← the only id anyone writes
     source_repo  <owner>/ACME.PARTS.CAP.SUP.007.WID-impl       ← and the only repo
 
-    actor_name         <repo half of source_repo>
+    actor_name         {capability}-implementation
     actor_slug         same, lowercased, dots to hyphens
     git_author_name    actor_name
     git_author_email   {actor_slug}@users.noreply.github.com
@@ -21,6 +21,15 @@ They are now derivations of two fields. Nothing in this package spells a capabil
     image_name(c)      {capability lowercased}-{c}
     image_ref(r, c, v) {r}/{capability_path}/{c}:{v}
 
+IDENTITY IS `capability` + ROLE, NOT THE REPO HALF. `actor_name` used to be whatever came after
+the `/` in `source_repo`, which reads as a derivation but is really an assumption: that one
+repository holds exactly one actor. Every sidecar in existence satisfies
+`source_repo == "<owner>/" + capability + "-" + ROLE`, so deriving the name from the two facts it
+was always shorthand for produces the identical string — and it keeps producing the right one when
+a capability's three actors come to share a repository, where the repo half would name all three
+the same thing. `source_repo` is unchanged and still required: it is where this actor clones from
+and pushes to, which is a different question from who it is.
+
 THE IMAGE REF IS A THREE-WAY CONTRACT. The testing actor recomputes the identical string and the
 orchestration actor parses it back apart. `image_ref` must therefore stay byte-identical to what
 those two agree on; it is derivation output or nothing, and no tag scheme is invented here.
@@ -53,6 +62,10 @@ _CARDS_PATH = Path(__file__).resolve().parent / "cards"
 # segments rather than concatenated.
 _CAPABILITY_SEGMENT = "cap"
 
+# The role this package plays for the capability it serves. Half of this actor's identity — see
+# `CapabilityConfig.actor_name` — and the half that is a property of the package, not of the use.
+ROLE = "implementation"
+
 # What an unsubstituted placeholder looks like: a bare lowercase word in braces, and nothing else.
 # Narrow on purpose — see `CapabilityConfig.expand`.
 _PLACEHOLDER = re.compile(r"\{([a-z_]+)\}")
@@ -187,9 +200,17 @@ class CapabilityConfig:
         ground_in = tuple(_grounding(entry, source, i)
                           for i, entry in enumerate(raw["ground_in"] or ()))
 
+        source_repo = str(raw["source_repo"])
+        owner, _, repo = source_repo.partition("/")
+        if not owner or not repo:
+            # `actor_name` used to be the repo half and validated this shape on the way past. It
+            # is derived from `capability` now, so the field every clone and push URL is built
+            # from needs checking in its own right rather than by a side effect.
+            raise ConfigError(f"{source}: source_repo '{source_repo}' is not '<owner>/<repo>'")
+
         config = cls(
             capability=str(raw["capability"]),
-            source_repo=str(raw["source_repo"]),
+            source_repo=source_repo,
             registry_repo=str(raw["registry_repo"]),
             engine=str(raw["engine"]),
             components=components,
@@ -204,13 +225,13 @@ class CapabilityConfig:
 
     @property
     def actor_name(self) -> str:
-        """The repo half of `source_repo` — this actor's own name, and its git author name."""
-        owner, _, repo = self.source_repo.partition("/")
-        if not owner or not repo:
-            raise ConfigError(
-                f"source_repo '{self.source_repo}' is not '<owner>/<repo>'"
-            )
-        return repo
+        """`{capability}-{ROLE}` — this actor's own name, and its git author name.
+
+        Not the repo half of `source_repo`, which is the same string for every sidecar that
+        exists but stops being this actor's name alone the moment a capability's actors share a
+        repository. See this module's own docstring.
+        """
+        return f"{self.capability}-{ROLE}"
 
     @property
     def actor_slug(self) -> str:

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/src/foundry_implementation_actor/schemas/agentic-context.schema.yaml

@@ -76,7 +76,8 @@ fields:
     type: string
     doc: >-
       `<owner>/<repo>` of the repository this actor clones, writes to, and pushes a branch to.
-      The actor's own name and its git commit identity are derived from the repo half.
+      Where it works, not who it is: the actor's own name and its git commit identity are
+      `<capability>-implementation`, derived from `capability` and this package's own role.
 
   registry_repo:
     type: string

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/tests/test_config.py

@@ -205,3 +205,45 @@ def test_components_may_not_be_empty(sidecar_dict, write_sidecar):
     sidecar_dict["components"] = []
     with pytest.raises(ConfigError, match="empty"):
         CapabilityConfig.load(write_sidecar(sidecar_dict))
+
+
+# ── identity: capability + role, not the repo half ──────────────────────────────────────────
+
+def test_the_actor_name_is_exactly_what_the_repo_half_used_to_be(config):
+    """The no-op half of the change, pinned.
+
+    `actor_name` was `source_repo.partition("/")[2]`. It is `{capability}-{ROLE}` now. Every
+    sidecar that exists satisfies `source_repo == "<owner>/" + capability + "-" + ROLE`, so the
+    two derivations agree on all of them — which is what makes this releasable on its own, ahead
+    of any repository moving.
+    """
+    assert config.source_repo == f"acme-lab/{config.capability}-implementation"
+    assert config.actor_name == config.source_repo.partition("/")[2]
+    assert config.actor_name == "ACME.PARTS.CAP.SUP.007.WID-implementation"
+
+
+def test_the_actor_name_no_longer_follows_the_repository(sidecar_dict, write_sidecar):
+    """The point of the change: three actors in one repository still have three names.
+
+    A consolidated capability repository is named for the capability alone, with no role suffix,
+    because all three of its actors live in it. Under the old derivation this actor would have
+    been called `ACME.PARTS.CAP.SUP.007.WID` — and so would both of its siblings.
+    """
+    sidecar_dict["source_repo"] = "acme-lab/ACME.PARTS.CAP.SUP.007.WID"
+    config = CapabilityConfig.load(write_sidecar(sidecar_dict))
+    assert config.actor_name == "ACME.PARTS.CAP.SUP.007.WID-implementation"
+    assert config.git_author_name == config.actor_name
+    assert config.actor_slug == "acme-parts-cap-sup-007-wid-implementation"
+    assert config.clone_prefix("TASK-042") == \
+        "acme-parts-cap-sup-007-wid-implementation-TASK-042-"
+
+
+def test_a_malformed_source_repo_is_still_refused(sidecar_dict, write_sidecar):
+    """`actor_name` used to validate this shape on its way past, and nothing else did.
+
+    `source_repo` is still what every clone and push URL is built from, so a `source_repo` that
+    is not `<owner>/<repo>` has to keep failing at load rather than at the first push.
+    """
+    sidecar_dict["source_repo"] = "just-a-name"
+    with pytest.raises(ConfigError, match="<owner>/<repo>"):
+        CapabilityConfig.load(write_sidecar(sidecar_dict))

{foundry_implementation_actor-0.6.0 → foundry_implementation_actor-0.7.0}/uv.lock

@@ -18,7 +18,7 @@ wheels = [
 
 [[package]]
 name = "foundry-implementation-actor"
-version = "0.6.0"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "papeete-actor-synchronous-messaging" },