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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.52.0
+Version: 0.53.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.53.0}/pyproject.toml

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

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

{aria_code-0.52.0 → aria_code-0.53.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.53.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.53.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.53.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.53.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.53.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()