orivane-cli 0.1.0__py3-none-any.whl

orivane_cli/__init__.py

@@ -0,0 +1 @@
+"""Orivane's local developer CLI."""

orivane_cli/__main__.py

@@ -0,0 +1,3 @@
+from ._main import main
+
+raise SystemExit(main())

orivane_cli/_commands.py

@@ -0,0 +1,76 @@
+"""Small command operations; application output is separate from telemetry."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+from ._config import load_config
+from ._loader import load_runner, project_path
+from ._trace import capture, format_spans
+
+_TEMPLATES = {
+    "orivane.toml": 'schema_version = 1\n\n[app]\nfactory = "app:create_runner"\n',
+    ".gitignore": ".env\n.venv/\n__pycache__/\n*.pyc\n",
+    "app.py": """from collections.abc import Awaitable, Callable
+
+from orivane_core import RunRequest
+from orivane_pydantic import PydanticAgentBackend
+from pydantic_ai.models.test import TestModel
+
+
+def create_runner() -> Callable[[str], Awaitable[object]]:
+    # TestModel is an offline starter only.
+    # Replace it with a real PydanticAI Model in your application when ready.
+    backend: PydanticAgentBackend[None, str] = PydanticAgentBackend(
+        TestModel(custom_output_text="offline starter"), output_type=str
+    )
+
+    async def run(prompt: str) -> object:
+        result = await backend.run(RunRequest(prompt, None))
+        return result.output
+
+    return run
+""",
+}
+
+
+class _InitError(ValueError):
+    pass
+
+
+def initialize(root: Path) -> None:
+    if root.exists() and (not root.is_dir() or any(root.iterdir())):
+        raise _InitError("initialization requires a new or empty directory")
+    root.mkdir(parents=True, exist_ok=True)
+    created: list[Path] = []
+    try:
+        for name, content in _TEMPLATES.items():
+            path = root / name
+            with path.open("x", encoding="utf-8", newline="\n") as target:
+                created.append(path)
+                target.write(content)
+    except OSError:
+        # Only remove files exclusively created by this invocation, never user files.
+        for path in created:
+            path.unlink()
+        raise
+
+
+async def _run(root: Path, factory: tuple[str, str], prompt: str) -> object:
+    with project_path(root.resolve()):
+        runner = load_runner(*factory)
+        return await runner(prompt)
+
+
+def execute(root: Path, *, tracing: bool) -> None:
+    factory = load_config(root)
+    prompt = sys.stdin.read()
+    if tracing:
+        with capture() as exporter:
+            result = asyncio.run(_run(root, factory, prompt))
+        print(str(result))
+        print("TRACE")
+        print(format_spans(exporter.get_finished_spans()))
+    else:
+        result = asyncio.run(_run(root, factory, prompt))
+        print(str(result))

orivane_cli/_config.py

@@ -0,0 +1,35 @@
+"""Static, strict TOML validation; never imports application code."""
+
+import keyword
+import tomllib
+from pathlib import Path
+
+
+class _ConfigError(ValueError):
+    """Contains only messages authored by the CLI, never input contents."""
+
+
+def load_config(root: Path) -> tuple[str, str]:
+    try:
+        with (root / "orivane.toml").open("rb") as source:
+            data = tomllib.load(source)
+    except (OSError, ValueError) as error:
+        raise _ConfigError("cannot read valid TOML") from error
+    if set(data) != {"schema_version", "app"}:
+        raise _ConfigError("expected only schema_version and app")
+    version = data["schema_version"]
+    if type(version) is not int or version != 1:
+        raise _ConfigError("unsupported schema_version")
+    app = data["app"]
+    if not isinstance(app, dict) or set(app) != {"factory"}:
+        raise _ConfigError("app must contain only factory")
+    factory = app["factory"]
+    if not isinstance(factory, str) or factory.count(":") != 1:
+        raise _ConfigError("factory must be module.path:callable_name")
+    module, attribute = factory.split(":")
+    if not all(
+        part.isidentifier() and not keyword.iskeyword(part)
+        for part in [*module.split("."), attribute]
+    ):
+        raise _ConfigError("factory must be module.path:callable_name")
+    return module, attribute

orivane_cli/_loader.py

@@ -0,0 +1,49 @@
+"""The sole dynamic application boundary; no reload system or Core-private imports."""
+
+import importlib
+import inspect
+import sys
+from collections.abc import Awaitable, Callable, Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import cast
+
+
+class _LoadError(Exception):
+    def __init__(self, error_type: str) -> None:
+        self.error_type = error_type
+
+
+@contextmanager
+def project_path(root: Path) -> Iterator[None]:
+    original = sys.path[:]
+    sys.path.insert(0, str(root))
+    try:
+        yield
+    finally:
+        sys.path[:] = original
+
+
+def load_runner(module: str, attribute: str) -> Callable[[str], Awaitable[object]]:
+    try:
+        factory: object = getattr(importlib.import_module(module), attribute)
+        if not callable(factory) or inspect.iscoroutinefunction(factory):
+            raise TypeError
+        runner: object = factory()
+        if inspect.iscoroutine(runner):
+            runner.close()
+            raise TypeError
+        if not callable(runner):
+            raise TypeError
+    except SystemExit:
+        raise _LoadError("SystemExit") from None
+    except Exception as error:
+        raise _LoadError(type(error).__name__) from None
+
+    async def invoke(prompt: str) -> object:
+        pending: object = runner(prompt)
+        if not inspect.isawaitable(pending):
+            raise TypeError
+        return await cast(Awaitable[object], pending)
+
+    return invoke

orivane_cli/_main.py

@@ -0,0 +1,67 @@
+"""argparse entry point with safe errors and stable exit codes."""
+
+import argparse
+import asyncio
+import sys
+from importlib.metadata import version
+from pathlib import Path
+from typing import NoReturn
+
+from ._commands import _InitError, execute, initialize
+from ._config import _ConfigError, load_config
+from ._loader import _LoadError
+from ._trace import _ProviderConfiguredError
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message: str) -> NoReturn:
+        # argparse's default text can echo rejected command-line values.
+        self.exit(2, "Invalid command usage; use --help.\n")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _Parser(prog="orivane", description="Local Orivane developer commands")
+    parser.add_argument("--version", action="version", version=version("orivane-cli"))
+    commands = parser.add_subparsers(dest="command", required=True)
+    for name, help_text in (
+        ("init", "Create an offline starter in a new or empty directory"),
+        ("validate", "Statically validate TOML without importing application code"),
+        ("run", "Run an application once with the entire stdin as its prompt"),
+        ("trace", "Run once and display local allowlisted spans"),
+    ):
+        command = commands.add_parser(name, help=help_text, description=help_text)
+        command.add_argument("path", nargs="?", default=".")
+    args = parser.parse_args(argv)
+    root = Path(args.path)
+    try:
+        if args.command == "init":
+            try:
+                initialize(root)
+            except OSError as error:
+                print("Initialization failed: " + type(error).__name__, file=sys.stderr)
+                return 2
+            print("INITIALIZED")
+        elif args.command == "validate":
+            load_config(root)
+            print("VALID")
+        else:
+            execute(root, tracing=args.command == "trace")
+        return 0
+    except (_ConfigError, _InitError) as error:
+        print("Invalid configuration or usage: " + error.args[0], file=sys.stderr)
+        return 2
+    except _LoadError as error:
+        print("Application load failed: " + error.error_type, file=sys.stderr)
+        return 1
+    except _ProviderConfiguredError:
+        print("Trace provider already configured", file=sys.stderr)
+        return 1
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        print("Interrupted", file=sys.stderr)
+        return 130
+    except SystemExit:
+        print("Run failed: SystemExit", file=sys.stderr)
+        return 1
+    except Exception as error:
+        print("Run failed: " + type(error).__name__, file=sys.stderr)
+        return 1

orivane_cli/_trace.py

@@ -0,0 +1,69 @@
+"""One-process, local SDK ownership and allowlisted structural formatting."""
+
+import json
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+_ATTRIBUTES = frozenset(
+    {
+        "orivane.component",
+        "orivane.operation",
+        "orivane.node.name",
+        "orivane.node.kind",
+        "orivane.backend.id",
+        "orivane.outcome",
+        "gen_ai.operation.name",
+    }
+)
+
+
+class _ProviderConfiguredError(Exception):
+    pass
+
+
+@contextmanager
+def capture() -> Iterator[InMemorySpanExporter]:
+    if not isinstance(trace.get_tracer_provider(), trace.ProxyTracerProvider):
+        raise _ProviderConfiguredError
+    provider = TracerProvider()
+    exporter = InMemorySpanExporter()
+    try:
+        provider.add_span_processor(SimpleSpanProcessor(exporter))
+        trace.set_tracer_provider(provider)
+        yield exporter
+    finally:
+        try:
+            provider.force_flush()
+        finally:
+            provider.shutdown()
+
+
+def format_spans(spans: Sequence[ReadableSpan]) -> str:
+    if not spans:
+        return "(no spans)"
+    rows = []
+    for span in sorted(spans, key=lambda item: (item.start_time or 0, item.name)):
+        context = span.context
+        rows.append(
+            json.dumps(
+                {
+                    "name": span.name,
+                    "trace_id": format(context.trace_id, "032x") if context else None,
+                    "span_id": format(context.span_id, "016x") if context else None,
+                    "parent_span_id": format(span.parent.span_id, "016x") if span.parent else None,
+                    "status": span.status.status_code.name,
+                    "attributes": {
+                        key: value
+                        for key, value in (span.attributes or {}).items()
+                        if key in _ATTRIBUTES
+                    },
+                },
+                sort_keys=True,
+            )
+        )
+    return "\n".join(rows)

orivane_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.5
+Name: orivane-cli
+Version: 0.1.0
+Summary: Local developer CLI for Orivane
+Project-URL: Repository, https://github.com/luyf579/orivane
+Project-URL: Documentation, https://github.com/luyf579/orivane/tree/main/docs
+Project-URL: Issues, https://github.com/luyf579/orivane/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,cli,opentelemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: opentelemetry-sdk<2,>=1.44
+Requires-Dist: orivane-backend-pydantic==0.1.0
+Requires-Dist: orivane-core==0.1.0
+Description-Content-Type: text/markdown
+
+# orivane-cli
+
+The local Orivane CLI, version 0.1.0, under the MIT license. The source is public;
+this is an early release and does not claim production readiness.
+
+The `orivane` command provides deterministic offline init, static TOML
+validate, stdin run and local structural trace. It uses a synchronous application
+factory returning an async runner. No provider schema, persistent sessions, remote
+exporter or automatic environment-file loading is included. Python 3.11/3.12 are
+tested. This distribution has a command interface, not an intended typed library API;
+it does not advertise PEP 561 support.
+
+Install the CLI and create an offline starter project in PowerShell:
+
+```powershell
+pipx install orivane-cli
+orivane init demo
+cd demo
+orivane validate .
+"hello" | orivane run .
+"hello" | orivane trace .
+```
+
+The generated starter uses offline TestModel and needs no API key. Installing the
+CLI resolves Core and the backend at exactly 0.1.0. Alternatively, use
+`pip install orivane-cli` inside a Python environment. For local development, use
+`uv sync --locked --all-packages` from the repository or locally built wheels.
+
+[Repository and documentation](https://github.com/luyf579/orivane) are public.
+
+## License
+
+MIT. The included LICENSE is an exact copy of the repository root license.

orivane_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+orivane_cli/__init__.py,sha256=THiXg7nENuvKUQRn9KYKanuRggvFs09NyUQhJEsACGw,37
+orivane_cli/__main__.py,sha256=VLqdG7fSvpLPDDXmeYtXBUmtt92f1aN1davbGhpo34Q,50
+orivane_cli/_commands.py,sha256=2MOIS3Wk3kx4sAXysuf9Xte2z9DB0PlmH-qkOUKGJY4,2434
+orivane_cli/_config.py,sha256=SoCbWkoW05LyJjxogu7283ZHTTOuyCOy26hAcPpQFc8,1345
+orivane_cli/_loader.py,sha256=G-Z9sdaktdv_KXEEM23U6t2v4XGeh2E4Lx3ccPWNhY4,1446
+orivane_cli/_main.py,sha256=8o2s0cyNf9si4zxXI0opBz9slSh5hS1S3L1XBRswE_A,2644
+orivane_cli/_trace.py,sha256=AOlRyk668yX0PX6u1YIiPcLP4BR5hzb3ZeDdZIy9Tnk,2215
+orivane_cli-0.1.0.dist-info/METADATA,sha256=xzpW8diAXgX8htP9WOxaTz7qucFE9RBoIwZqqNXBhD4,2056
+orivane_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+orivane_cli-0.1.0.dist-info/entry_points.txt,sha256=uUpwBQF1LAXWT611NgleVQNEFp0S5LS2Pn-N7A6gQRk,51
+orivane_cli-0.1.0.dist-info/licenses/LICENSE,sha256=mXz7jOIJWuMFkIE1TjKNXQNqii060bxmUzFg4Ddk9vo,1077
+orivane_cli-0.1.0.dist-info/RECORD,,

orivane_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

orivane_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+orivane = orivane_cli._main:main

orivane_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orivane contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.