bigpowers 2.88.9 → 2.88.11

package/tests/test_srp_engine.py

@@ -6,7 +6,9 @@ Run: python3 -m pytest tests/test_srp_engine.py -v
 """
 import os
 import sys
+import tempfile
 import unittest
+from unittest import mock
 
 # Make scripts/lib importable without installation.
 _REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -144,5 +146,153 @@ class TestRewriteLinksForPi(unittest.TestCase):
         self.assertNotIn("](REFERENCE.md)", result)  # real link rewritten
 
 
+class TestResolveBash(unittest.TestCase):
+    """Regression: dispatch must not make subprocess resolve the bare name
+    'bash'. On Windows the Win32 CreateProcess search order finds the WSL
+    stub in System32 before Git Bash on PATH, so setup aborted with
+    'Windows Subsystem for Linux has no installed distributions'."""
+
+    def test_env_override_wins(self):
+        with mock.patch.dict(os.environ, {"BIGPOWERS_BASH": "/custom/bash"}):
+            self.assertEqual(_srp.resolve_bash(), "/custom/bash")
+
+    def test_uses_path_resolved_bash(self):
+        env = {k: v for k, v in os.environ.items() if k != "BIGPOWERS_BASH"}
+        with mock.patch.dict(os.environ, env, clear=True):
+            with mock.patch.object(_srp.shutil, "which", return_value="/usr/bin/bash"):
+                self.assertEqual(_srp.resolve_bash(), "/usr/bin/bash")
+
+    def test_falls_back_to_bare_bash(self):
+        env = {k: v for k, v in os.environ.items() if k != "BIGPOWERS_BASH"}
+        with mock.patch.dict(os.environ, env, clear=True):
+            with mock.patch.object(_srp.shutil, "which", return_value=None):
+                self.assertEqual(_srp.resolve_bash(), "bash")
+
+
+class TestDispatchUsesResolvedBash(unittest.TestCase):
+    """The adapter subprocess must receive the PATH-resolved bash path, not
+    the bare name that Windows resolves to the WSL stub."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.repo_root = self._tmp.name
+        adapter_dir = os.path.join(self.repo_root, "scripts", "adapters")
+        os.makedirs(adapter_dir)
+        self.adapter = os.path.join(adapter_dir, "fake.sh")
+        with open(self.adapter, "w", encoding="utf-8") as f:
+            f.write("#!/usr/bin/env bash\n")
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_dispatch_passes_resolved_bash_to_popen(self):
+        captured = {}
+
+        class _FakeProc:
+            returncode = 0
+
+            def communicate(self, input=None):
+                return ("", "")
+
+        def _fake_popen(cmd, **kwargs):
+            captured["cmd"] = cmd
+            return _FakeProc()
+
+        sentinel = os.path.join(self.repo_root, "git-bash")
+        with mock.patch.object(_srp, "resolve_bash", return_value=sentinel):
+            with mock.patch.object(_srp.subprocess, "Popen", side_effect=_fake_popen):
+                _srp.dispatch_to_adapter({"name": "x"}, "fake", self.repo_root)
+
+        self.assertEqual(captured["cmd"][0], sentinel)
+        self.assertEqual(captured["cmd"][1], self.adapter)
+
+
+class TestWriteIrStream(unittest.TestCase):
+    """#138: the whole run's IR is serialised once."""
+
+    def test_writes_nul_delimited_fields_in_order(self):
+        records = [{
+            'name': 'demo',
+            'description': 'a "demo"',
+            'model': 'gpt',
+            'body': 'line1\nline2',
+        }]
+        with mock.patch.object(_srp, 'rewrite_links_for_pi', return_value='PI-BODY'):
+            path = _srp._write_ir_stream(records)
+        try:
+            with open(path, 'rb') as f:
+                data = f.read()
+        finally:
+            os.unlink(path)
+        self.assertEqual(data, b'demo\x00a "demo"\x00gpt\x00line1\nline2\x00PI-BODY\x00')
+
+
+class TestRenderAll(unittest.TestCase):
+    """#138: one bash process per adapter, not one per skill×adapter."""
+
+    @staticmethod
+    def _records(n):
+        return [{'name': f's{i}', 'description': 'd', 'model': '', 'body': 'b'} for i in range(n)]
+
+    def test_one_process_per_adapter_not_per_skill(self):
+        records = self._records(5)
+        with mock.patch.object(_srp, '_write_ir_stream', return_value='/tmp/ir.bin') as write, \
+                mock.patch.object(_srp.os, 'unlink') as unlink, \
+                mock.patch.object(_srp.subprocess, 'run') as run:
+            run.return_value = mock.Mock(returncode=0)
+            _srp.render_all(records, ['cursor', 'pi'], _REPO_ROOT)
+        self.assertEqual(write.call_count, 1)
+        self.assertEqual(run.call_count, 2)
+        unlink.assert_called_once_with('/tmp/ir.bin')
+
+    def test_nonzero_adapter_exits_nonzero(self):
+        with mock.patch.object(_srp, '_write_ir_stream', return_value='/tmp/ir.bin'), \
+                mock.patch.object(_srp.os, 'unlink'), \
+                mock.patch.object(_srp.subprocess, 'run') as run:
+            run.return_value = mock.Mock(returncode=3)
+            with self.assertRaises(SystemExit):
+                _srp.render_all(self._records(1), ['cursor'], _REPO_ROOT)
+
+    def test_empty_records_does_not_spawn(self):
+        with mock.patch.object(_srp.subprocess, 'run') as run:
+            _srp.render_all([], ['cursor'], _REPO_ROOT)
+        run.assert_not_called()
+
+    def test_missing_adapter_exits_without_spawning(self):
+        with mock.patch.object(_srp, '_write_ir_stream', return_value='/tmp/ir.bin'), \
+                mock.patch.object(_srp.os, 'unlink'), \
+                mock.patch.object(_srp.subprocess, 'run') as run:
+            with self.assertRaises(SystemExit):
+                _srp.render_all(self._records(1), ['not-a-real-adapter'], _REPO_ROOT)
+        run.assert_not_called()
+
+
+class TestAdapterRenderAllDriver(unittest.TestCase):
+    """#138: the bash driver sources one adapter and renders the stream."""
+
+    def test_driver_renders_stream_in_a_single_process(self):
+        import shutil
+        import subprocess
+
+        driver = os.path.join(_REPO_ROOT, 'scripts', 'lib', 'adapter-render-all.sh')
+        adapter = os.path.join(_REPO_ROOT, 'scripts', 'adapters', 'cursor.sh')
+        with tempfile.TemporaryDirectory() as tmp:
+            stream = os.path.join(tmp, 'ir.bin')
+            with open(stream, 'wb') as f:
+                for field in ('demo-skill', 'desc', '', 'body text', 'body text'):
+                    f.write(field.encode())
+                    f.write(b'\x00')
+            env = dict(os.environ)
+            env['CURSOR_RULES'] = tmp
+            proc = subprocess.run(
+                [shutil.which('bash') or 'bash', driver, adapter, stream],
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self.assertEqual(proc.returncode, 0, proc.stderr)
+            self.assertTrue(os.path.isfile(os.path.join(tmp, 'demo-skill.mdc')))
+
+
 if __name__ == "__main__":
     unittest.main()

package/allure-results/categories.json

@@ -1,23 +0,0 @@
-[
-  {
-    "name": "P0 Risk",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*risk.*P0.*"
-  },
-  {
-    "name": "Security Review",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*security.*(?:medium|high).*"
-  },
-  {
-    "name": "Open Bugs",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*Bug.*"
-  }
-]

package/allure-results/executor.json

@@ -1,6 +0,0 @@
-{
-  "name": "bigpowers",
-  "type": "bigpowers",
-  "buildName": "2.76.2",
-  "buildOrder": 328
-}