urirun 0.3.17__tar.gz

urirun-0.3.17/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: urirun
+Version: 0.3.17
+Summary: Language-agnostic URI to handler adapter
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.18
+Requires-Dist: pydantic>=2
+Provides-Extra: grpc
+Requires-Dist: grpcio>=1.60; extra == "grpc"
+Provides-Extra: planfile
+Requires-Dist: planfile>=0.1.103; extra == "planfile"
+Provides-Extra: llm
+Requires-Dist: litellm>=1.60; extra == "llm"
+Provides-Extra: host
+Requires-Dist: planfile>=0.1.103; extra == "host"
+Requires-Dist: litellm>=1.60; extra == "host"
+Provides-Extra: test
+Requires-Dist: planfile>=0.1.103; extra == "test"
+Requires-Dist: pytest>=7; extra == "test"
+
+# urirun python adapter
+
+Install directly from GitHub:
+
+```bash
+pip install "git+https://github.com/if-uri/urirun.git@v0.3.13#subdirectory=adapters/python"
+```
+
+Or install a GitHub Release wheel:
+
+```bash
+pip install "https://github.com/if-uri/urirun/releases/download/v0.3.13/urirun-0.3.13-py3-none-any.whl"
+```
+
+PyPI publishing is not required. The distribution is named `urirun`; the Python
+import package remains `urirun`:
+
+```python
+import urirun
+```
+
+After installation the `urirun` CLI is available:
+
+```bash
+urirun scan ./project --out .urirun/bindings.v2.json --registry-out .urirun/registry.merged.json
+urirun validate .urirun/bindings.v2.json
+urirun list .urirun/registry.merged.json
+urirun run 'cli://local/git/status' .urirun/registry.merged.json
+```
+
+`urirun-v1` and `urirun-v2` are also installed as explicit versioned entry
+points for scripts that need a stable major-version command.
+
+The optional v2 gRPC transport can be installed with:
+
+```bash
+pip install "urirun[grpc] @ git+https://github.com/if-uri/urirun.git@v0.3.13#subdirectory=adapters/python"
+```
+
+v2 can generate schema-first bindings and a compiled registry from existing
+artifacts:
+
+```bash
+urirun scan ./project \
+  --out generated/bindings.v2.json \
+  --registry-out generated/registry.json
+urirun validate generated/bindings.v2.json
+urirun list generated/registry.json
+```
+
+Connector packages can generate bindings directly from decorated Python
+functions. The shortest path is to declare the connector once and then attach
+short URI paths to functions:
+
+```python
+import urirun
+
+connector = urirun.connector("http-check", scheme="httpcheck")
+
+@connector.command("http/query/status")
+def status_command(url: str, expectStatus: int = 200, timeout: float = 10.0):
+    return ["urirun-http-check", "status", "{url}", "--expect-status", "{expectStatus}"]
+
+def urirun_bindings():
+    return connector.bindings()
+```
+
+
+## License
+
+Licensed under Apache-2.0.

urirun-0.3.17/README.md

@@ -0,0 +1,71 @@
+# urirun python adapter
+
+Install directly from GitHub:
+
+```bash
+pip install "git+https://github.com/if-uri/urirun.git@v0.3.13#subdirectory=adapters/python"
+```
+
+Or install a GitHub Release wheel:
+
+```bash
+pip install "https://github.com/if-uri/urirun/releases/download/v0.3.13/urirun-0.3.13-py3-none-any.whl"
+```
+
+PyPI publishing is not required. The distribution is named `urirun`; the Python
+import package remains `urirun`:
+
+```python
+import urirun
+```
+
+After installation the `urirun` CLI is available:
+
+```bash
+urirun scan ./project --out .urirun/bindings.v2.json --registry-out .urirun/registry.merged.json
+urirun validate .urirun/bindings.v2.json
+urirun list .urirun/registry.merged.json
+urirun run 'cli://local/git/status' .urirun/registry.merged.json
+```
+
+`urirun-v1` and `urirun-v2` are also installed as explicit versioned entry
+points for scripts that need a stable major-version command.
+
+The optional v2 gRPC transport can be installed with:
+
+```bash
+pip install "urirun[grpc] @ git+https://github.com/if-uri/urirun.git@v0.3.13#subdirectory=adapters/python"
+```
+
+v2 can generate schema-first bindings and a compiled registry from existing
+artifacts:
+
+```bash
+urirun scan ./project \
+  --out generated/bindings.v2.json \
+  --registry-out generated/registry.json
+urirun validate generated/bindings.v2.json
+urirun list generated/registry.json
+```
+
+Connector packages can generate bindings directly from decorated Python
+functions. The shortest path is to declare the connector once and then attach
+short URI paths to functions:
+
+```python
+import urirun
+
+connector = urirun.connector("http-check", scheme="httpcheck")
+
+@connector.command("http/query/status")
+def status_command(url: str, expectStatus: int = 200, timeout: float = 10.0):
+    return ["urirun-http-check", "status", "{url}", "--expect-status", "{expectStatus}"]
+
+def urirun_bindings():
+    return connector.bindings()
+```
+
+
+## License
+
+Licensed under Apache-2.0.

urirun-0.3.17/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urirun"
+version = "0.3.17"
+description = "Language-agnostic URI to handler adapter"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+dependencies = [
+  "jsonschema>=4.18",
+  "pydantic>=2",
+]
+
+[project.optional-dependencies]
+grpc = ["grpcio>=1.60"]
+planfile = ["planfile>=0.1.103"]
+llm = ["litellm>=1.60"]
+host = ["planfile>=0.1.103", "litellm>=1.60"]
+test = ["planfile>=0.1.103", "pytest>=7"]
+
+[project.scripts]
+urirun = "urirun.v2:main"
+urirun-v1 = "urirun.v1:main"
+urirun-v2 = "urirun.v2:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["urirun*"]
+
+[tool.pfix]
+# Self-healing Python configuration
+model = "openrouter/qwen/qwen3-coder-next"
+auto_apply = false
+auto_install_deps = true
+auto_restart = false
+max_retries = 3
+create_backups = false
+git_auto_commit = false
+
+[tool.pfix.runtime_todo]
+enabled = true
+todo_file = "TODO.md"
+min_severity = "low"
+deduplicate = true
+
+[tool.costs]
+# AI Cost tracking configuration
+badge = true
+update_readme = true
+readme_path = "README.md"
+default_model = "openrouter/qwen/qwen3-coder-next"
+analysis_mode = "byok"
+full_history = true
+max_commits = 500
+
+# Cost thresholds for badge colors (USD)
+badge_color_thresholds = { low = 1.0, medium = 5.0, high = 10.0, critical = 50.0 }

urirun-0.3.17/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

urirun-0.3.17/tests/test_adopt_pack.py

@@ -0,0 +1,75 @@
+"""Adopting a capability-pack manifest as bindings.v2 (least-invasive URI adoption)."""
+import json
+import subprocess
+import sys
+import unittest
+
+from urirun import v2
+from urirun.runtime import adopt_pack
+
+MANIFEST = {
+    "id": "demopack",
+    "version": 1,
+    "scheme": "demo",
+    "uri_patterns": [
+        {"pattern": "demo://host/status/query/info", "kind": "query",
+         "operation": "demo.status.info", "side_effects": False, "approval": "not_required"},
+        {"pattern": "demo://host/task/command/run", "kind": "command",
+         "operation": "demo.task.run", "side_effects": True, "approval": "required"},
+    ],
+    "handlers": {"python": {
+        "demo.status.info": "python://demopack.handlers:status_info",
+        "demo.task.run": "python://demopack.handlers:task_run",
+    }},
+}
+
+
+class AdoptPackTests(unittest.TestCase):
+    def test_manifest_maps_to_bindings(self):
+        bindings = {b["uri"]: b for b in adopt_pack.manifest_bindings(MANIFEST)}
+        self.assertEqual(set(bindings), {"demo://host/status/query/info", "demo://host/task/command/run"})
+        q = bindings["demo://host/status/query/info"]
+        self.assertEqual(q["adapter"], "local-function")
+        self.assertEqual(q["ref"], "demopack.handlers:status_info")
+        self.assertEqual(q["meta"]["uriKind"], "query")
+        self.assertNotIn("policy", q)  # no side effects / approval
+
+    def test_side_effects_and_approval_become_policy(self):
+        cmd = {b["uri"]: b for b in adopt_pack.manifest_bindings(MANIFEST)}["demo://host/task/command/run"]
+        self.assertEqual(cmd["policy"], {"approval": "required", "sideEffects": True})
+
+    def test_document_validates_and_compiles(self):
+        # write a JSON manifest so no YAML dependency is needed
+        import tempfile, os
+        fd, path = tempfile.mkstemp(suffix=".json")
+        os.write(fd, json.dumps(MANIFEST).encode())
+        os.close(fd)
+        try:
+            doc = adopt_pack.adopt(path)
+            self.assertEqual(doc["version"], v2.VERSION)
+            self.assertEqual(len(doc["bindings"]), 2)
+            registry = v2.compile_registry(doc)  # must not raise
+            self.assertTrue(registry.get("routes") or registry.get("tree") or registry)
+        finally:
+            os.unlink(path)
+
+    def test_hydrated_route_executes(self):
+        from urirun import _registry as reg, _runtime as rt
+        import tempfile, os
+        fd, path = tempfile.mkstemp(suffix=".json")
+        os.write(fd, json.dumps(MANIFEST).encode())
+        os.close(fd)
+        try:
+            registry = v2.compile_registry(adopt_pack.adopt(path))
+            hydrated = reg.hydrate_registry(registry, {
+                "demopack.handlers:status_info": lambda t, a, p, d: {"ok": True, "where": t},
+            })
+            env = rt.run("demo://host/status/query/info", hydrated, mode="execute",
+                         policy={"execute": {"allow": ["demo://*"]}})
+            self.assertTrue(env.get("ok"))
+        finally:
+            os.unlink(path)
+
+
+if __name__ == "__main__":
+    unittest.main()

urirun-0.3.17/tests/test_agent_command.py

@@ -0,0 +1,57 @@
+"""Tests for `urirun agent` (action space + planner loop)."""
+
+from __future__ import annotations
+
+import sys
+
+import urirun
+from urirun.runtime import agent
+
+
+def _registry():
+    emit_json = [sys.executable, "-c", "print('{\"ok\": true, \"v\": 1}')"]
+    doc = {
+        "version": "urirun.bindings.v2",
+        "bindings": {
+            "demo://host/thing/query/read": {
+                "adapter": "argv-template", "kind": "command", "argv": emit_json,
+                "inputSchema": {"type": "object", "additionalProperties": False, "properties": {}},
+                "meta": {"connector": "demo", "label": "read"}, "uri": "demo://host/thing/query/read",
+            },
+            "demo://host/thing/command/write": {
+                "adapter": "argv-template", "kind": "command", "argv": emit_json,
+                "inputSchema": {"type": "object", "additionalProperties": False, "properties": {}},
+                "meta": {"connector": "demo", "label": "write"}, "uri": "demo://host/thing/command/write",
+            },
+        },
+    }
+    return urirun.compile_registry(doc)
+
+
+def test_action_space_marks_query_and_command():
+    space = {r["uri"]: r for r in agent.action_space(_registry())}
+    assert space["demo://host/thing/query/read"]["kind"] == "query"
+    assert space["demo://host/thing/command/write"]["kind"] == "command"
+
+
+def test_run_plan_runs_query_and_gates_command():
+    registry = _registry()
+    steps = [
+        {"uri": "demo://host/thing/query/read", "payload": {}},
+        {"uri": "demo://host/thing/command/write", "payload": {}},
+    ]
+    trace = agent.run_plan(registry, steps, allow_commands=False)
+    read, write = trace
+    assert read["ran"] is True and read["ok"] is True and read["data"]["v"] == 1
+    assert write["ran"] is False  # command gated
+
+
+def test_run_plan_allows_command_with_permission():
+    registry = _registry()
+    trace = agent.run_plan(registry, [{"uri": "demo://host/thing/command/write", "payload": {}}], allow_commands=True)
+    assert trace[0]["ran"] is True and trace[0]["ok"] is True
+
+
+def test_load_planner_resolves_module_function():
+    fn = agent._load_planner("urirun.runtime.agent:action_space")
+    assert fn is agent.action_space

urirun-0.3.17/tests/test_compat.py

@@ -0,0 +1,99 @@
+# Author: Tom Sapletta · https://tom.sapletta.com
+# Part of the ifURI solution.
+
+import contextlib
+import io
+import json
+import unittest
+from unittest.mock import patch
+
+import urirun
+from urirun import compat
+
+
+def _healthy_importable(name):
+    # backend host/node layers stay in core; namecheap was extracted (removed),
+    # its connector replacement is installed.
+    if name == "urirun.namecheap_dns":
+        return False
+    if name == "urirun_connector_namecheap_dns":
+        return True
+    return bool(name and (name.startswith("urirun.host.") or name.startswith("urirun.node.")))
+
+
+class CompatReportTests(unittest.TestCase):
+    def test_backend_layer_is_kept(self):
+        with patch.object(compat, "_entry_point_names", return_value={"namecheap-dns"}), \
+             patch.object(compat, "_importable", side_effect=_healthy_importable):
+            data = compat.report()
+
+        host_db = next(m for m in data["modules"] if m["module"] == "urirun.host.host_db")
+        self.assertEqual(host_db["owner"], "backend")
+        self.assertEqual(host_db["layer"], "host")
+        self.assertEqual(host_db["reusedBy"], "urirun-connector-sqlite-context")
+        self.assertTrue(host_db["currentImportable"])
+        self.assertEqual(host_db["status"], "kept")
+
+    def test_namecheap_is_extracted(self):
+        with patch.object(compat, "_entry_point_names", return_value={"namecheap-dns"}), \
+             patch.object(compat, "_importable", side_effect=_healthy_importable):
+            data = compat.report()
+
+        nc = next(m for m in data["modules"] if m["module"] == "urirun.namecheap_dns")
+        self.assertEqual(nc["owner"], "extracted")
+        self.assertFalse(nc["currentImportable"])  # removed from core
+        self.assertTrue(nc["replacementInstalled"])
+        self.assertEqual(nc["status"], "extracted")
+        self.assertTrue(data["ok"])
+
+    def test_top_level_api_exposes_compat_report(self):
+        data = urirun.compat_report()
+        self.assertTrue(data["ok"])
+        self.assertTrue(any(m["module"] == "urirun.host.host_integrations" for m in data["modules"]))
+
+    def test_cli_list_json_reports_node_layer(self):
+        with patch.object(compat, "_entry_point_names", return_value={"namecheap-dns"}), \
+             patch.object(compat, "_importable", side_effect=_healthy_importable):
+            buffer = io.StringIO()
+            with contextlib.redirect_stdout(buffer):
+                code = compat.main(["list", "--json"])
+
+        self.assertEqual(code, 0)
+        data = json.loads(buffer.getvalue())
+        self.assertTrue(data["ok"])
+        self.assertGreater(data["backendLayers"], 0)
+        self.assertEqual(data["extracted"], 1)
+        mesh = next(m for m in data["modules"] if m["module"] == "urirun.node.mesh")
+        self.assertEqual(mesh["layer"], "node")
+
+    def test_cli_check_ok_when_layers_present_and_namecheap_extracted(self):
+        with patch.object(compat, "_entry_point_names", return_value={"namecheap-dns"}), \
+             patch.object(compat, "_importable", side_effect=_healthy_importable), \
+             contextlib.redirect_stdout(io.StringIO()):
+            code = compat.main(["check"])
+
+        self.assertEqual(code, 0)
+
+    def test_cli_check_nonzero_when_namecheap_replacement_missing(self):
+        def importable(name):
+            # backend present, but the namecheap connector is NOT installed
+            return bool(name and (name.startswith("urirun.host.") or name.startswith("urirun.node.")))
+
+        with patch.object(compat, "_entry_point_names", return_value=set()), \
+             patch.object(compat, "_importable", side_effect=importable), \
+             contextlib.redirect_stdout(io.StringIO()):
+            code = compat.main(["check"])
+
+        self.assertEqual(code, 1)
+
+    def test_cli_check_nonzero_when_backend_layer_missing(self):
+        with patch.object(compat, "_entry_point_names", return_value={"namecheap-dns"}), \
+             patch.object(compat, "_importable", return_value=False), \
+             contextlib.redirect_stdout(io.StringIO()):
+            code = compat.main(["check"])
+
+        self.assertEqual(code, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

urirun-0.3.17/tests/test_connect_catalog.py

@@ -0,0 +1,165 @@
+"""Tests for the connect.ifuri.com catalog client (no network)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+import pytest
+
+from urirun import connect_catalog
+
+
+CATALOG = {
+    "version": "ifuri.connectors.v1",
+    "defaultPipSpec": "urirun @ git+https://example/urirun",
+    "connectors": [
+        {
+            "id": "planfile",
+            "name": "Planfile Tasks",
+            "status": "available",
+            "category": "Planning",
+            "summary": "Tasks via task:// URIs.",
+            "uriSchemes": ["task", "planfile"],
+            "routes": ["task://host/tickets/query/list"],
+            "install": {"mode": "urirun-extra", "pipSpec": "urirun-connector-planfile @ git+https://example/planfile"},
+        },
+        {
+            "id": "sqlite-context",
+            "name": "SQLite Context",
+            "status": "available",
+            "category": "Data",
+            "uriSchemes": ["data"],
+            "install": {"mode": "bundled"},
+        },
+        {
+            "id": "mqtt",
+            "name": "MQTT",
+            "status": "planned",
+            "category": "IoT",
+            "install": {"mode": "planned", "pipSpec": "urirun-connectors-mqtt"},
+        },
+    ],
+}
+
+
+def _args(**kw):
+    kw.setdefault("catalog", "https://connect.ifuri.com")
+    return argparse.Namespace(**kw)
+
+
+def test_resolve_install_buckets():
+    plan = connect_catalog.resolve_install(CATALOG, ["planfile", "sqlite-context", "mqtt", "ghost"])
+    assert [item["pipSpec"] for item in plan["pipSpecs"]] == ["urirun-connector-planfile @ git+https://example/planfile"]
+    assert plan["bundled"] == ["sqlite-context"]
+    assert [s["id"] for s in plan["skipped"]] == ["mqtt"]
+    assert plan["unknown"] == ["ghost"]
+
+
+def test_pip_install_command_uses_current_interpreter():
+    command = connect_catalog.pip_install_command(["pkg-a", "pkg-b"])
+    assert command[1:] == ["-m", "pip", "install", "pkg-a", "pkg-b"]
+
+
+def test_install_dry_run_does_not_run_pip(monkeypatch, capsys):
+    monkeypatch.setattr(connect_catalog, "fetch_catalog", lambda base="": CATALOG)
+    ran = {"called": False}
+    monkeypatch.setattr(connect_catalog.subprocess, "run", lambda *a, **k: ran.__setitem__("called", True))
+
+    rc = connect_catalog.connectors_command(_args(connectors_command="install", ids=["planfile"], execute=False, json=False))
+
+    assert rc == 0
+    assert ran["called"] is False
+    out = capsys.readouterr().out
+    assert "dry-run" in out
+    assert "urirun-connector-planfile" in out
+
+
+def test_install_execute_invokes_pip(monkeypatch):
+    monkeypatch.setattr(connect_catalog, "fetch_catalog", lambda base="": CATALOG)
+    calls = {}
+
+    class _Result:
+        returncode = 0
+
+    def fake_run(command, *a, **k):
+        calls["command"] = command
+        return _Result()
+
+    monkeypatch.setattr(connect_catalog.subprocess, "run", fake_run)
+
+    rc = connect_catalog.connectors_command(_args(connectors_command="install", ids=["planfile"], execute=True, json=False))
+
+    assert rc == 0
+    assert calls["command"][1:4] == ["-m", "pip", "install"]
+    assert "urirun-connector-planfile @ git+https://example/planfile" in calls["command"]
+
+
+def test_install_unknown_only_returns_error(monkeypatch):
+    monkeypatch.setattr(connect_catalog, "fetch_catalog", lambda base="": CATALOG)
+    rc = connect_catalog.connectors_command(_args(connectors_command="install", ids=["ghost"], execute=False, json=False))
+    assert rc == 1
+
+
+def test_list_available_filter(monkeypatch, capsys):
+    monkeypatch.setattr(connect_catalog, "fetch_catalog", lambda base="": CATALOG)
+    rc = connect_catalog.connectors_command(_args(connectors_command="list", available=True, json=False))
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "planfile" in out
+    assert "mqtt" not in out  # planned filtered out
+
+
+def test_show_json(monkeypatch, capsys):
+    monkeypatch.setattr(connect_catalog, "fetch_connector", lambda cid, base="": {"connector": CATALOG["connectors"][0], "installCommand": "curl ... | bash"})
+    rc = connect_catalog.connectors_command(_args(connectors_command="show", id="planfile", json=True))
+    assert rc == 0
+    assert '"id": "planfile"' in capsys.readouterr().out
+
+
+def test_diff_manifest_in_sync():
+    entry = CATALOG["connectors"][0]
+    assert connect_catalog.diff_manifest(entry, entry) == []
+
+
+def test_diff_manifest_detects_route_and_pipspec_drift():
+    local = json.loads(json.dumps(CATALOG["connectors"][0]))
+    local["routes"] = local["routes"] + ["task://host/extra/query/new"]
+    local["install"]["pipSpec"] = "urirun-connector-planfile @ git+https://example/planfile@v9"
+    diffs = connect_catalog.diff_manifest(local, CATALOG["connectors"][0])
+    fields = {d["field"] for d in diffs}
+    assert "routes" in fields
+    assert "install.pipSpec" in fields
+    routes_diff = next(d for d in diffs if d["field"] == "routes")
+    assert routes_diff["onlyLocal"] == ["task://host/extra/query/new"]
+
+
+def test_check_in_sync(monkeypatch, tmp_path, capsys):
+    manifest = tmp_path / "connector.manifest.json"
+    manifest.write_text(json.dumps(CATALOG["connectors"][0]), encoding="utf-8")
+    monkeypatch.setattr(connect_catalog, "fetch_connector", lambda cid, base="": {"connector": CATALOG["connectors"][0]})
+    rc = connect_catalog.connectors_command(_args(connectors_command="check", manifest=str(manifest), json=False))
+    assert rc == 0
+    assert "in sync" in capsys.readouterr().out
+
+
+def test_check_drift_returns_1(monkeypatch, tmp_path, capsys):
+    drifted = json.loads(json.dumps(CATALOG["connectors"][0]))
+    drifted["install"]["pipSpec"] = "urirun-connector-planfile @ git+https://example/planfile@vOLD"
+    manifest = tmp_path / "connector.manifest.json"
+    manifest.write_text(json.dumps(drifted), encoding="utf-8")
+    monkeypatch.setattr(connect_catalog, "fetch_connector", lambda cid, base="": {"connector": CATALOG["connectors"][0]})
+    rc = connect_catalog.connectors_command(_args(connectors_command="check", manifest=str(manifest), json=False))
+    assert rc == 1
+    assert "mismatch" in capsys.readouterr().err
+
+
+def test_catalog_network_error_returns_1(monkeypatch):
+    import urllib.error
+
+    def boom(base="", timeout=10.0):
+        raise urllib.error.URLError("offline")
+
+    monkeypatch.setattr(connect_catalog, "fetch_catalog", boom)
+    rc = connect_catalog.connectors_command(_args(connectors_command="list", available=False, json=False))
+    assert rc == 1