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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.52.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.52.0 → aria_code-0.54.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.52.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.52.0 → aria_code-0.54.0}/src/aria_code/_version.py

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

{aria_code-0.52.0 → aria_code-0.54.0}/src/aria_code/apps/channels/intake.py

@@ -59,12 +59,12 @@ async def analyze_alert_via_gateway(
     decides its own fallback (the daemon keeps its legacy quick summary).
     """
     if run_turn_fn is None:
-        # stream_ollama borrows 47 bare names from aria_cli's module globals
-        # (verified by AST audit) and only works after aria_cli's import-time
-        # rebinding. Until that module is untangled, any out-of-CLI consumer
-        # of the default Ollama path must import aria_cli first — a one-time
-        # ~1s cost the long-lived daemon amortizes.
-        import aria_cli  # noqa: F401  (side effect: binds stream_ollama globals)
+        # No `import aria_cli` here any more. It was unconditional, for the sake
+        # of the Ollama path's rebind, and cost 1766ms against the 63ms this
+        # module's own dependencies need — paid by every channel alert including
+        # the ones analysed through the cloud, which never reach stream_ollama.
+        # runtime_bridge now imports it inside the ollama branch, so the cost
+        # follows the route that needs it.
         from apps.cli.providers.runtime_bridge import build_tool_executor, make_provider_fn
         from runtime.gateway import run_turn as run_turn_fn_impl
 

{aria_code-0.52.0 → aria_code-0.54.0}/src/aria_code/apps/cli/providers/runtime_bridge.py

@@ -266,6 +266,23 @@ def make_provider_fn(
             )
 
         async def run_ollama(_on_token):
+            if route == "ollama":
+                # stream_ollama still borrows 12 names from aria_cli's module
+                # globals and only resolves them after that module's import-time
+                # rebind, so an out-of-CLI caller has to import it first. Doing
+                # it here rather than at the caller's import time means only the
+                # route that needs it pays: measured, `import aria_cli` is 1766ms
+                # against 63ms for the daemon's own dependencies, and a
+                # Vertex/Gemini config routes to "configured", which never
+                # touches stream_ollama. The daemon was paying 1.7s to forward an
+                # alert it then analysed through the cloud.
+                #
+                # Idempotent and cached by sys.modules, so the second alert pays
+                # nothing. Inside the function, not the module, because importing
+                # aria_cli at this module's import time would put the cost back
+                # on every consumer.
+                import aria_cli  # noqa: F401  (side effect: rebinds stream_ollama)
+
             selected = (
                 OllamaProvider(ollama_url, model, system_override=system_override)
                 if route == "ollama" else

{aria_code-0.52.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.52.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.52.0 → aria_code-0.54.0}/src/aria_code.egg-info/SOURCES.txt

@@ -563,6 +563,7 @@ tests/test_import_graph_budget.py
 tests/test_intent_router.py
 tests/test_intent_signals.py
 tests/test_kling_video_client.py
+tests/test_lazy_rebind.py
 tests/test_legacy_module_imports.py
 tests/test_license_consistency.py
 tests/test_licensing.py

{aria_code-0.52.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.52.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.54.0/tests/test_lazy_rebind.py

@@ -0,0 +1,112 @@
+"""aria_cli is imported by the route that needs it, not by every caller.
+
+stream_ollama still borrows 12 names from aria_cli's module globals and only
+resolves them after that module's import-time rebind, so an out-of-CLI caller
+has to import it before taking the Ollama path. apps/channels/intake.py did that
+unconditionally, which meant a channel alert analysed through Vertex — a route
+that never touches stream_ollama — paid for the whole CLI anyway.
+
+Measured on the first-alert setup path:
+
+    cloud / configured    1539ms -> 117ms
+    ollama                still imports it, at provider construction
+
+The import is inside run_ollama rather than at runtime_bridge's module level for
+the same reason it left intake: at module level the cost returns to everyone.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import sys
+import textwrap
+import unittest
+
+PRELUDE = "import sys; sys.path[:0] = ['src', 'src/aria_code', '.']\n"
+
+
+def _in_subprocess(body: str) -> str:
+    """Run in a fresh interpreter: sys.modules is global, so an earlier test
+    importing aria_cli would make any in-process assertion vacuous."""
+    proc = subprocess.run(
+        [sys.executable, "-c", PRELUDE + textwrap.dedent(body)],
+        capture_output=True, text=True, timeout=300,
+    )
+    assert proc.returncode == 0, proc.stderr[-800:]
+    return proc.stdout
+
+
+class TheCloudRouteDoesNotImportTheCli(unittest.TestCase):
+    def test_building_a_cloud_provider_leaves_aria_cli_unimported(self):
+        out = _in_subprocess("""
+            from apps.cli.providers.runtime_bridge import make_provider_fn
+            make_provider_fn(model='google/gemini-2.5-pro',
+                             config={'local_provider': 'vertex'},
+                             api_url='https://gw.example',
+                             ollama_url='http://localhost:11434', tool_schemas=[])
+            print('aria_cli' in sys.modules)
+        """)
+        self.assertEqual(out.strip(), "False",
+                         "the cloud route imported the whole CLI")
+
+    def test_importing_intake_does_not_import_the_cli(self):
+        out = _in_subprocess("""
+            from apps.channels import intake  # noqa: F401
+            print('aria_cli' in sys.modules)
+        """)
+        self.assertEqual(out.strip(), "False")
+
+    def test_intake_has_no_unconditional_cli_import(self):
+        """The regression is textual: an `import aria_cli` on the default branch
+        applies to every route, and nothing about a cloud turn needs it."""
+        import pathlib
+
+        source = (pathlib.Path(__file__).resolve().parents[1] / "src" / "aria_code"
+                  / "apps" / "channels" / "intake.py").read_text(encoding="utf-8")
+        offenders = [line.strip() for line in source.splitlines()
+                     if line.strip().startswith(("import aria_cli", "from aria_cli"))]
+        self.assertEqual(offenders, [], f"intake.py imports aria_cli: {offenders}")
+
+
+class TheOllamaRouteStillGetsItsRebind(unittest.TestCase):
+    def test_the_provider_call_imports_the_cli_and_the_borrowed_names_resolve(self):
+        """Moving the import must not leave stream_ollama unbound. A closed port
+        makes the call fail after the rebind, which is the part being checked."""
+        out = _in_subprocess("""
+            import asyncio
+            from apps.cli.providers.runtime_bridge import make_provider_fn
+
+            fn = make_provider_fn(model='qwen2.5:7b',
+                                  config={'local_provider': 'ollama'},
+                                  api_url=None,
+                                  ollama_url='http://127.0.0.1:1',
+                                  tool_schemas=[])
+            print('before:', 'aria_cli' in sys.modules)
+
+            async def main():
+                try:
+                    await fn('hi', [])
+                except Exception:
+                    pass
+
+            asyncio.run(main())
+            print('after:', 'aria_cli' in sys.modules)
+
+            cli = sys.modules.get('aria_cli')
+            globs = getattr(cli, 'stream_ollama', None)
+            globs = globs.__globals__ if globs is not None else {}
+            needed = ('_ACTIVE_COMMAND_POLICY', '_CONFIRM_TOOLS',
+                      'execute_local_tool', '_print_tool_result', 'get_ariarc')
+            print('missing:', [n for n in needed if n not in globs])
+        """)
+        self.assertIn("before: False", out)
+        self.assertIn("after: True", out,
+                      "the ollama route did not import aria_cli — stream_ollama "
+                      "would run with unbound globals")
+        self.assertIn("missing: []", out,
+                      "stream_ollama's borrowed names did not resolve after the rebind")
+
+
+if __name__ == "__main__":
+    unittest.main()

{aria_code-0.52.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.52.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.52.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.52.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",