aria-code 0.53.0__tar.gz → 0.54.0__tar.gz

{aria_code-0.53.0 → aria_code-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.53.0
+Version: 0.54.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artherahq/aria-code

{aria_code-0.53.0 → aria_code-0.54.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.53.0"
+version = "0.54.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.53.0 → aria_code-0.54.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.53.0"
+__version__ = "0.54.0"

{aria_code-0.53.0 → aria_code-0.54.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.53.0
+Version: 0.54.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artherahq/aria-code

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_dispatcher_pins_match_the_release.py

@@ -50,6 +50,7 @@ class ThePinsMatchTheDispatchersOwnVersion(unittest.TestCase):
     def test_every_platform_is_listed(self) -> None:
         listed = set(self.manifest.get("optionalDependencies") or {})
         expected = {f"@artheras/aria-code-{k}" for k in PLATFORM_KEYS}
+        expected |= {f"@artheras/aria-code-mcp-{k}" for k in PLATFORM_KEYS}
         self.assertEqual(
             listed, expected,
             "the dispatcher must list exactly the platform packages the release "
@@ -85,7 +86,8 @@ class BumpingTheVersionMovesThePins(unittest.TestCase):
                 "name": "@artheras/aria-code",
                 "version": "0.47.0",
                 "optionalDependencies": {
-                    f"@artheras/aria-code-{k}": "0.47.0" for k in PLATFORM_KEYS
+                    **{f"@artheras/aria-code-{k}": "0.47.0" for k in PLATFORM_KEYS},
+                    **{f"@artheras/aria-code-mcp-{k}": "0.47.0" for k in PLATFORM_KEYS},
                 },
             }, indent=2) + "\n")
             (work / "scripts" / "bump_version.py").write_text(

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_doctor_describes_the_current_install.py

@@ -116,9 +116,11 @@ class ThePlatformKeyMatchesTheOnesWePublish(unittest.TestCase):
         )
 
     def test_the_dispatcher_lists_exactly_those(self) -> None:
-        listed = {name.rsplit("aria-code-", 1)[-1]
-                  for name in (NPM_PKG.get("optionalDependencies") or {})}
-        self.assertEqual(listed, {v for v in self.CASES.values() if v})
+        names = set(NPM_PKG.get("optionalDependencies") or {})
+        expected = {v for v in self.CASES.values() if v}
+        cli = {f"@artheras/aria-code-{key}" for key in expected}
+        mcp = {f"@artheras/aria-code-mcp-{key}" for key in expected}
+        self.assertEqual(names, cli | mcp)
 
 
 class TheBinaryCheckReportsASilentlyMissingPackage(unittest.TestCase):

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_platform_package_assembly.py

@@ -26,8 +26,10 @@ of the two shows up.
 from __future__ import annotations
 
 import pathlib
+import json
 import shutil
 import subprocess
+import sys
 import tempfile
 import unittest
 
@@ -131,37 +133,55 @@ class AFullSetOfArtifactsAssembles(_Fixture):
                 self.assertIn(f"{platform}=built/{mcp_dir}/{mcp_file}", args)
 
 
-class MissingArtifactsDoNotKillTheStep(_Fixture):
-    """A platform that failed to build must be skipped, not fatal.
+class MissingArtifactsStopTheRelease(_Fixture):
+    """Every binary pinned by the dispatcher must be available."""
 
-    This is the property the workflow comment claims ("A build that failed must
-    not become an empty package") and that bug 2 silently removed.
-    """
-
-    def test_a_missing_mcp_binary_is_a_warning(self) -> None:
+    def test_a_missing_mcp_binary_fails_before_packaging(self) -> None:
         for platform in ARTIFACTS:
             self.place(platform, mcp=False)
         proc = _run(self.script, self.built)
-        self.assertEqual(proc.returncode, 0,
-                         f"a missing MCP binary ended the step:\n{proc.stderr[-800:]}")
-        self.assertIn("::warning::", proc.stdout)
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertIn("no MCP binary", proc.stdout)
+        self.assertNotIn("ARG:", proc.stdout)
 
-    def test_a_missing_platform_is_a_warning(self) -> None:
+    def test_a_missing_platform_fails_before_packaging(self) -> None:
         self.place("linux-x64")
         proc = _run(self.script, self.built)
-        self.assertEqual(proc.returncode, 0,
-                         f"a missing platform ended the step:\n{proc.stderr[-800:]}")
-        args = [l[4:] for l in proc.stdout.splitlines() if l.startswith("ARG:")]
-        self.assertIn("linux-x64=built/aria-code-linux-x64/aria-code-bin", args)
-        self.assertNotIn("--binary", [a for a in args if "darwin" in a])
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertIn("no CLI binary for darwin-arm64", proc.stdout)
+        self.assertNotIn("ARG:", proc.stdout)
 
-    def test_no_artifacts_at_all_still_reaches_python(self) -> None:
-        # Nothing to package is the script's job to report ("no --binary
-        # given"), not something bash should die on first.
+    def test_no_artifacts_at_all_fails_before_packaging(self) -> None:
         self.built.mkdir(parents=True)
         proc = _run(self.script, self.built)
-        self.assertEqual(proc.returncode, 0,
-                         f"an empty artifact set ended the step:\n{proc.stderr[-800:]}")
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertIn("no CLI binary", proc.stdout)
+        self.assertNotIn("ARG:", proc.stdout)
+
+
+class PlatformPackagesAreSplit(_Fixture):
+    def test_cli_and_mcp_have_separate_tarball_inputs(self) -> None:
+        for platform in ARTIFACTS:
+            self.place(platform)
+        out = self.tmp / "packages"
+        args = [sys.executable, str(ROOT / "scripts" / "make_platform_packages.py"),
+                "--version", "9.9.9", "--out", str(out)]
+        for platform, (cli_dir, cli_file, mcp_dir, mcp_file) in ARTIFACTS.items():
+            args += ["--binary", f"{platform}={self.built / cli_dir / cli_file}",
+                     "--mcp", f"{platform}={self.built / mcp_dir / mcp_file}"]
+        proc = subprocess.run(args, capture_output=True, text=True, timeout=20)
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(len(list(out.iterdir())), 10)
+        for platform in ARTIFACTS:
+            for kind, name in (("", "aria-code-bin"), ("mcp-", "aria-code-mcp-bin")):
+                package = out / f"aria-code-{kind}{platform}"
+                manifest = json.loads((package / "package.json").read_text())
+                self.assertEqual(manifest["name"], f"@artheras/aria-code-{kind}{platform}")
+                self.assertEqual(manifest["version"], "9.9.9")
+                binaries = list((package / "bin").iterdir())
+                self.assertEqual(len(binaries), 1)
+                extension = ".exe" if platform.startswith("win32") else ""
+                self.assertEqual(binaries[0].name, f"{name}{extension}")
 
 
 if __name__ == "__main__":

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_platform_packages.py

@@ -52,10 +52,7 @@ class GeneratedPackages(unittest.TestCase):
         self.out = self.tmp / "platforms"
 
     def _build(self, key, mcp=False):
-        binaries = {"aria-code-bin": self.fake}
-        if mcp:
-            binaries["aria-code-mcp-bin"] = self.fake
-        return mpp.build_one(key, "9.9.9", binaries, self.out)
+        return mpp.build_one(key, "9.9.9", self.fake, self.out, mcp=mcp)
 
     def test_windows_binaries_get_exe_and_nothing_else_does(self):
         win = self._build("win32-x64")
@@ -88,17 +85,20 @@ class GeneratedPackages(unittest.TestCase):
         self.assertEqual(meta["version"], "9.9.9")
         self.assertEqual(meta["files"], ["bin/"])
 
-    def test_the_mcp_binary_is_optional_and_named_the_same_way(self):
-        without = self._build("linux-x64")
-        self.assertFalse((without / "bin" / "aria-code-mcp-bin").exists())
-        with_mcp = self._build("darwin-arm64", mcp=True)
-        self.assertTrue((with_mcp / "bin" / "aria-code-mcp-bin").is_file())
+    def test_the_mcp_binary_has_its_own_package(self):
+        cli = self._build("darwin-arm64")
+        mcp = self._build("darwin-arm64", mcp=True)
+        self.assertFalse((cli / "bin" / "aria-code-mcp-bin").exists())
+        self.assertTrue((mcp / "bin" / "aria-code-mcp-bin").is_file())
+        self.assertEqual(json.loads((mcp / "package.json").read_text())["name"],
+                         "@artheras/aria-code-mcp-darwin-arm64")
 
     def test_rebuilding_replaces_rather_than_accumulates(self):
-        pkg = self._build("linux-x64", mcp=True)
-        self.assertTrue((pkg / "bin" / "aria-code-mcp-bin").is_file())
-        pkg = self._build("linux-x64", mcp=False)
-        self.assertFalse((pkg / "bin" / "aria-code-mcp-bin").exists(),
+        pkg = self._build("linux-x64")
+        stale = pkg / "bin" / "aria-code-mcp-bin"
+        stale.write_bytes(b"stale")
+        pkg = self._build("linux-x64")
+        self.assertFalse(stale.exists(),
                          "a stale binary from a previous build would be published")
 
 

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_release_chain.py

@@ -12,7 +12,10 @@ that fails by doing nothing.
 
 from __future__ import annotations
 
+import os
 import pathlib
+import subprocess
+import tempfile
 import unittest
 
 import yaml
@@ -157,5 +160,41 @@ class CalledWorkflowsAcceptATag(unittest.TestCase):
                         self.assertIn("inputs.tag", str(ref))
 
 
+class NpmDispatcherGate(unittest.TestCase):
+    """Exercise the actual release step without contacting npm."""
+
+    def _run_wait(self, npm_available: bool):
+        steps = _load("publish")["jobs"]["publish-npm"]["steps"]
+        script = next(step["run"] for step in steps
+                      if step.get("name") == "Wait for this version's platform packages")
+        # Keep the real shell logic, but expire its wait immediately in the
+        # missing-package case instead of making the test sleep 30 minutes.
+        self.assertIn("+ 1800", script)
+        script = script.replace("+ 1800", "+ 0", 1)
+        with tempfile.TemporaryDirectory() as tmp:
+            bin_dir = pathlib.Path(tmp)
+            node = bin_dir / "node"
+            node.write_text(
+                "#!/bin/sh\n"
+                "if [ \"$1\" = -p ]; then echo 0.52.0; "
+                "else echo @artheras/aria-code-linux-x64@0.52.0; fi\n"
+            )
+            npm = bin_dir / "npm"
+            npm.write_text(f"#!/bin/sh\nexit {0 if npm_available else 1}\n")
+            node.chmod(0o755)
+            npm.chmod(0o755)
+            env = dict(os.environ, PATH=f"{tmp}:{os.environ.get('PATH', '')}",
+                       INPUT_TAG="v0.52.0")
+            return subprocess.run(["bash", "-c", script], env=env,
+                                  capture_output=True, text=True, timeout=10)
+
+    def test_dispatcher_waits_for_its_platform_packages(self):
+        present = self._run_wait(True)
+        self.assertEqual(present.returncode, 0, present.stderr)
+        missing = self._run_wait(False)
+        self.assertNotEqual(missing.returncode, 0)
+        self.assertIn("Refusing to publish a dispatcher", missing.stdout)
+
+
 if __name__ == "__main__":
     unittest.main()

{aria_code-0.53.0 → aria_code-0.54.0}/tests/test_release_reaches_the_registries.py

@@ -75,13 +75,13 @@ class ThePublishedVersionIsVerified(unittest.TestCase):
                       "reporting a missing package without failing is the same "
                       "silence this job exists to break")
 
-    def test_the_platform_packages_are_reported(self) -> None:
-        # Their absence is a warning rather than an error: a platform whose
-        # build failed should not fail the whole release, but it must be said,
-        # because npm skipping an unresolvable optionalDependency is silent.
+    def test_missing_platform_packages_fail_the_release(self) -> None:
+        # npm silently skips unavailable optionalDependencies, so a published
+        # dispatcher without its pinned binaries is not a working release.
         script = "\n".join(str(s.get("run", "")) for s in self.job.get("steps") or [])
-        self.assertIn("aria-code-$key", script)
-        self.assertIn("::warning::", script)
+        self.assertIn("manifest.optionalDependencies", script)
+        self.assertIn("::error::no $pkg", script)
+        self.assertIn("MISSING=1", script)
 
 
 # The job graph — that publishing no longer waits on the npm binaries, and
@@ -92,15 +92,17 @@ class ThePublishedVersionIsVerified(unittest.TestCase):
 
 class TheNpmPageDescribesTheCurrentProduct(unittest.TestCase):
     def test_the_two_manifests_agree(self) -> None:
+        import ast
         import json
-        import tomllib
+        import re
 
         root = WORKFLOWS.parents[1]
         npm = json.loads((root / "npm" / "package.json").read_text(encoding="utf-8"))
-        with (root / "pyproject.toml").open("rb") as fh:
-            py = tomllib.load(fh)["project"]
+        project_section = (root / "pyproject.toml").read_text(encoding="utf-8").split("[project]", 1)[1].split("\n[", 1)[0]
+        description = re.search(r'^description\s*=\s*(".*")\s*$', project_section, re.MULTILINE)
+        self.assertIsNotNone(description)
         self.assertEqual(
-            npm["description"], py["description"],
+            npm["description"], ast.literal_eval(description.group(1)),
             "the npm page's one-line pitch and PyPI's disagree; npm's said "
             "'AI-powered financial terminal' long after the project was "
             "repositioned, and it is the first line a visitor reads",