axor-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{axor_cli-0.1.0 → axor_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axor-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: CLI for axor-core governance kernel — governed agent sessions in your terminal
 Project-URL: Bug Tracker, https://github.com/Bucha11/axor-cli/issues
 Project-URL: Changelog, https://github.com/Bucha11/axor-cli/releases
@@ -17,24 +17,28 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Terminals
 Requires-Python: >=3.11
-Requires-Dist: axor-core>=0.1.0
+Requires-Dist: axor-core>=0.3.0
 Provides-Extra: all
 Requires-Dist: axor-claude>=0.1.0; extra == 'all'
 Requires-Dist: axor-openai>=0.1.0; extra == 'all'
+Requires-Dist: axor-telemetry>=0.1.0; extra == 'all'
 Provides-Extra: claude
 Requires-Dist: axor-claude>=0.1.0; extra == 'claude'
 Provides-Extra: dev
+Requires-Dist: axor-telemetry>=0.1.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Provides-Extra: openai
 Requires-Dist: axor-openai>=0.1.0; extra == 'openai'
+Provides-Extra: telemetry
+Requires-Dist: axor-telemetry>=0.1.0; extra == 'telemetry'
 Description-Content-Type: text/markdown
 
 # axor-cli
 
-[![CI](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml)
-[![PyPI](https://img.shields.io/pypi/v/axor-cli)](https://pypi.org/project/axor-cli/)
-[![Python](https://img.shields.io/pypi/pyversions/axor-cli)](https://pypi.org/project/axor-cli/)
+[![CI](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/axor-cli?cacheSeconds=300)](https://pypi.org/project/axor-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/axor-cli?cacheSeconds=300)](https://pypi.org/project/axor-cli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 

{axor_cli-0.1.0 → axor_cli-0.2.0}/README.md

@@ -1,8 +1,8 @@
 # axor-cli
 
-[![CI](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml)
-[![PyPI](https://img.shields.io/pypi/v/axor-cli)](https://pypi.org/project/axor-cli/)
-[![Python](https://img.shields.io/pypi/pyversions/axor-cli)](https://pypi.org/project/axor-cli/)
+[![CI](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Bucha11/axor-cli/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/axor-cli?cacheSeconds=300)](https://pypi.org/project/axor-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/axor-cli?cacheSeconds=300)](https://pypi.org/project/axor-cli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 

axor_cli-0.2.0/axor_cli/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{axor_cli-0.1.0 → axor_cli-0.2.0}/axor_cli/adapters.py

@@ -60,6 +60,7 @@ def build_session(
     system_prompt: str | None = None,
     load_skills: bool = True,
     load_plugins: bool = True,
+    telemetry: Any | None = None,
 ) -> GovernedSession:
     """
     Import the adapter package and build a GovernedSession.
@@ -94,6 +95,9 @@ def build_session(
     if soft_token_limit is not None:
         kwargs["soft_token_limit"] = soft_token_limit
 
+    if telemetry is not None:
+        kwargs["telemetry"] = telemetry
+
     # model and system_prompt are passed to the executor inside make_session
     # adapters should accept **session_kwargs and forward to their executor
     if model:

axor_cli-0.2.0/axor_cli/auth.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+"""
+API key management for axor-cli.
+
+Priority order (highest to lowest):
+    1. --api-key CLI flag          (one-off, never saved)
+    2. ADAPTER_API_KEY env var     (e.g. ANTHROPIC_API_KEY)
+    3. ~/.axor/config.toml         (persistent, 0600 permissions)
+    4. None -> prompt via /auth
+
+~/.axor/config.toml format:
+    [claude]
+    api_key = "sk-ant-..."
+
+    [openai]
+    api_key = "sk-..."
+"""
+
+import getpass
+import logging
+import os
+import stat
+import tempfile
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    try:
+        import tomli as tomllib  # fallback
+    except ImportError:
+        tomllib = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+# Configuration paths
+CONFIG_DIR = Path.home() / ".axor"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+# File permissions for config (owner read/write only)
+CONFIG_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR  # 0600
+
+# Environment variable names per adapter
+_ENV_VARS: dict[str, str] = {
+    "claude": "ANTHROPIC_API_KEY",
+    "openai": "OPENAI_API_KEY",
+}
+
+
+# ============================================================================
+# Public API
+# ============================================================================
+
+
+def resolve_api_key(adapter: str, flag_key: str | None = None) -> str | None:
+    """
+    Resolve API key using priority chain.
+    
+    Priority order:
+        1. CLI flag (flag_key parameter)
+        2. Environment variable (ADAPTER_API_KEY)
+        3. Config file (~/.axor/config.toml)
+    
+    Args:
+        adapter: Name of the adapter (e.g., "claude", "openai")
+        flag_key: Optional API key from CLI flag (highest priority)
+    
+    Returns:
+        API key string or None if not found
+    """
+    # 1. CLI flag has highest priority
+    if flag_key:
+        return flag_key
+
+    # 2. Check environment variable
+    key = _get_key_from_env(adapter)
+    if key:
+        return key
+
+    # 3. Check config file
+    key = load_from_config(adapter)
+    if key:
+        # Set in environment so adapter executables can pick it up
+        _set_key_in_env(adapter, key)
+        return key
+
+    return None
+
+
+def load_from_config(adapter: str) -> str | None:
+    """
+    Load API key from ~/.axor/config.toml.
+    
+    Args:
+        adapter: Name of the adapter section in config
+    
+    Returns:
+        API key string or None if not found
+    """
+    if not CONFIG_FILE.exists():
+        return None
+
+    if tomllib is None:
+        logger.warning("TOML support unavailable (install tomli for Python <3.11)")
+        return None
+
+    try:
+        config = _read_config_file()
+        return config.get(adapter, {}).get("api_key")
+    except Exception as e:
+        logger.warning("Failed to read %s: %s", CONFIG_FILE, e)
+        return None
+
+
+def save_to_config(adapter: str, api_key: str) -> None:
+    """
+    Save API key to ~/.axor/config.toml with 0600 permissions.
+    
+    Args:
+        adapter: Name of the adapter section
+        api_key: API key to save
+    """
+    existing = _load_existing_config()
+    
+    if adapter not in existing:
+        existing[adapter] = {}
+    existing[adapter]["api_key"] = api_key
+    
+    _write_config(existing)
+
+
+def clear_from_config(adapter: str) -> bool:
+    """
+    Remove adapter key from config.
+    
+    Args:
+        adapter: Name of the adapter section to remove
+    
+    Returns:
+        True if key existed and was removed, False otherwise
+    """
+    if not CONFIG_FILE.exists():
+        return False
+
+    if tomllib is None:
+        logger.warning("TOML support unavailable — cannot clear config")
+        return False
+
+    try:
+        existing = _read_config_file()
+    except Exception as e:
+        logger.warning("Failed to read config: %s", e)
+        return False
+
+    if adapter not in existing:
+        return False
+
+    del existing[adapter]
+    _write_config(existing)
+    return True
+
+
+def prompt_and_save(adapter: str) -> str | None:
+    """
+    Interactively prompt for API key and optionally save to config.
+    
+    Args:
+        adapter: Name of the adapter
+    
+    Returns:
+        The entered API key or None if user cancelled
+    """
+    env_var_name = _get_env_var_name(adapter)
+    
+    _print_prompt_header(adapter, env_var_name)
+    
+    key = _prompt_for_key(adapter)
+    if not key:
+        return None
+    
+    _offer_to_save_key(adapter, key)
+    _set_key_in_env(adapter, key)
+    
+    return key
+
+
+# ============================================================================
+# Private helpers - Environment variable handling
+# ============================================================================
+
+
+def _get_env_var_name(adapter: str) -> str:
+    """Get the environment variable name for an adapter."""
+    return _ENV_VARS.get(adapter, f"{adapter.upper()}_API_KEY")
+
+
+def _get_key_from_env(adapter: str) -> str | None:
+    """Get API key from environment variable."""
+    env_var = _ENV_VARS.get(adapter)
+    if env_var:
+        return os.environ.get(env_var)
+    return None
+
+
+def _set_key_in_env(adapter: str, key: str) -> None:
+    """Set API key in environment variable."""
+    env_var = _ENV_VARS.get(adapter)
+    if env_var:
+        os.environ[env_var] = key
+
+
+# ============================================================================
+# Private helpers - Config file I/O
+# ============================================================================
+
+
+def _read_config_file() -> dict[str, Any]:
+    """Read and parse the config file."""
+    with open(CONFIG_FILE, "rb") as f:
+        return tomllib.load(f)  # type: ignore
+
+
+def _load_existing_config() -> dict[str, Any]:
+    """Load existing config or return empty dict if not available."""
+    if not CONFIG_FILE.exists() or tomllib is None:
+        return {}
+    
+    try:
+        return _read_config_file()
+    except Exception as e:
+        logger.warning("Failed to read existing config: %s", e)
+        return {}
+
+
+def _escape_toml_value(val: str) -> str:
+    """Escape a string for TOML double-quoted value."""
+    return val.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _serialize_config_to_toml(data: dict[str, Any]) -> str:
+    """Serialize config dict to TOML format."""
+    lines: list[str] = []
+    for section, values in data.items():
+        lines.append(f"[{section}]")
+        for key, val in values.items():
+            escaped_val = _escape_toml_value(str(val))
+            lines.append(f'{key} = "{escaped_val}"')
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _write_config(data: dict[str, Any]) -> None:
+    """
+    Write config dict to file atomically with 0600 permissions.
+    
+    Uses atomic write pattern: write to temp file with restricted permissions,
+    then replace the original file.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    
+    toml_content = _serialize_config_to_toml(data)
+    
+    # Atomic write: create temp with restricted perms, then replace
+    fd, tmp_path = tempfile.mkstemp(dir=CONFIG_DIR, prefix=".axor_cfg_")
+    try:
+        # Set permissions before writing content
+        os.fchmod(fd, CONFIG_FILE_MODE)
+        with os.fdopen(fd, "w") as f:
+            f.write(toml_content)
+        os.replace(tmp_path, CONFIG_FILE)
+    except Exception:
+        # Clean up temp file on error
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise
+
+
+# ============================================================================
+# Private helpers - Interactive prompts
+# ============================================================================
+
+
+def _print_prompt_header(adapter: str, env_var_name: str) -> None:
+    """Print header for interactive prompt."""
+    print(f"\n  No API key found for '{adapter}'.")
+    print(f"  (checked: --api-key flag, {env_var_name} env var, {CONFIG_FILE})\n")
+
+
+def _prompt_for_key(adapter: str) -> str | None:
+    """
+    Prompt user for API key.
+    
+    Returns:
+        Entered key or None if cancelled/empty
+    """
+    try:
+        key = getpass.getpass(
+            f"  {adapter.capitalize()} API key (hidden): "
+        ).strip()
+    except (KeyboardInterrupt, EOFError):
+        print()
+        return None
+
+    if not key:
+        print("  No key entered.")
+        return None
+    
+    return key
+
+
+def _should_save_key() -> bool:
+    """Ask user if they want to save the key."""
+    try:
+        response = input(
+            "  Save to ~/.axor/config.toml for future sessions? [Y/n]: "
+        ).strip().lower()
+    except (KeyboardInterrupt, EOFError):
+        print()
+        return False
+    
+    return response in ("", "y", "yes")
+
+
+def _offer_to_save_key(adapter: str, key: str) -> None:
+    """Offer to save the key to config and execute the save if accepted."""
+    if _should_save_key():
+        try:
+            save_to_config(adapter, key)
+            print(f"  Saved to {CONFIG_FILE} (permissions: 600)")
+        except Exception as e:
+            print(f"  Could not save: {e}")
+    else:
+        print("  Key not saved — valid for this session only.")

{axor_cli-0.1.0 → axor_cli-0.2.0}/axor_cli/display.py

@@ -19,6 +19,8 @@ import threading
 # ── Color support ──────────────────────────────────────────────────────────────
 
 def _supports_color() -> bool:
+    if os.environ.get("NO_COLOR") is not None:
+        return False
     if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
         return False
     return os.environ.get("TERM", "") != "dumb"
@@ -68,8 +70,8 @@ class Spinner:
     _FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
 
     def __init__(self, prefix: str = "") -> None:
-        self._prefix  = prefix
-        self._running = False
+        self._prefix = prefix
+        self._stop_event = threading.Event()
         self._thread: threading.Thread | None = None
 
     def start(self) -> None:
@@ -77,25 +79,26 @@ class Spinner:
             sys.stdout.write(dim("thinking...\n"))
             sys.stdout.flush()
             return
-        self._running = True
-        self._thread  = threading.Thread(target=self._spin, daemon=True)
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
         self._thread.start()
 
     def stop(self) -> None:
-        self._running = False
+        self._stop_event.set()
         if self._thread:
             self._thread.join(timeout=0.5)
+            self._thread = None
         if _COLOR:
             sys.stdout.write("\r\033[K")   # clear spinner line
             sys.stdout.flush()
 
     def _spin(self) -> None:
         i = 0
-        while self._running:
+        while not self._stop_event.is_set():
             frame = self._FRAMES[i % len(self._FRAMES)]
             sys.stdout.write(f"\r{dim(self._prefix)}{dim(frame)} ")
             sys.stdout.flush()
-            time.sleep(0.08)
+            self._stop_event.wait(timeout=0.08)
             i += 1
 
 

{axor_cli-0.1.0 → axor_cli-0.2.0}/axor_cli/main.py

@@ -27,7 +27,7 @@ for _candidate in [
         sys.path.insert(0, os.path.abspath(_candidate))
         break
 
-from axor_cli import display, auth, adapters, streaming
+from axor_cli import display, auth, adapters, streaming, telemetry
 from axor_cli._version import __version__
 
 
@@ -38,6 +38,10 @@ Built-in commands:
   /auth              Set or update API key (saved to ~/.axor/config.toml)
   /auth --clear      Remove saved API key
   /auth --show       Show where key is loaded from (never shows the key)
+  /telemetry         Show telemetry status
+  /telemetry on      Enable local telemetry (adds --remote to also ship)
+  /telemetry off     Disable telemetry
+  /telemetry preview Print the last queued telemetry record
   /cost              Token usage for this session
   /policy            Last execution policy
   /compact           Compress context (reduces token usage)
@@ -182,6 +186,7 @@ async def repl(session, adapter: str, args: argparse.Namespace) -> None:
                             soft_token_limit=args.limit,
                             load_skills=not args.no_skills,
                             load_plugins=not args.no_plugins,
+                            telemetry=telemetry.build_pipeline(axor_version=__version__),
                         )
                         session = new_session
                         display.print_success("Session ready.")
@@ -205,6 +210,11 @@ async def repl(session, adapter: str, args: argparse.Namespace) -> None:
                                    f"Restart with: axor {adapter} --model {parts[1]}")
             continue
 
+        # ── /telemetry (CLI-local, not governance) ─────────────────────────────
+        if line.startswith("/telemetry"):
+            telemetry.handle_slash(line)
+            continue
+
         # ── Governed slash commands (forwarded to session) ─────────────────────
         if line.startswith("/"):
             result = await session.run(line)
@@ -264,6 +274,10 @@ async def async_main() -> int:
             display.print_error("No API key. Exiting.")
             return 1
 
+    # one-time opt-in banner (no-op after first run, suppressed by AXOR_NO_BANNER)
+    telemetry.maybe_show_first_run_banner()
+    pipeline = telemetry.build_pipeline(axor_version=__version__)
+
     # build session
     try:
         session = adapters.build_session(
@@ -274,6 +288,7 @@ async def async_main() -> int:
             soft_token_limit=args.limit,
             load_skills=not args.no_skills,
             load_plugins=not args.no_plugins,
+            telemetry=pipeline,
         )
     except Exception as e:
         display.print_error(f"Could not start session: {e}")

{axor_cli-0.1.0 → axor_cli-0.2.0}/axor_cli/streaming.py

@@ -68,10 +68,11 @@ async def _stream_run(
     summary: dict[str, Any],
 ) -> None:
     text_received = False
-    executor = session._executor
 
-    # streaming path — adapter exposes set_text_callback()
-    if hasattr(executor, "set_text_callback"):
+    # streaming path — session.executor exposes set_text_callback()
+    # Use getattr to avoid depending on GovernedSession internals
+    executor = getattr(session, "executor", None) or getattr(session, "_executor", None)
+    if executor and hasattr(executor, "set_text_callback"):
         def on_text(chunk: str) -> None:
             nonlocal text_received
             if not text_received:

axor_cli-0.2.0/axor_cli/telemetry.py

@@ -0,0 +1,151 @@
+"""
+axor-cli <-> axor-telemetry bridge.
+
+Keeps axor-telemetry as an optional dependency: everything here no-ops when
+the package is not importable. The REPL and startup never see exceptions
+from the telemetry path.
+
+Responsibilities:
+  - Resolve TelemetryConfig from ~/.axor/config.toml + env.
+  - Build a TelemetryPipeline when mode != off.
+  - Show a one-time stderr banner if telemetry is off and no marker exists,
+    so users discover the opt-in without being prompted mid-session.
+  - Run `/telemetry` CLI-side subcommands (status / on / off / preview).
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+_MARKER_PATH = Path.home() / ".axor" / ".telemetry_notice_shown"
+
+
+def _is_importable() -> bool:
+    try:
+        import axor_telemetry  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def build_pipeline(axor_version: str = "") -> Any | None:
+    """
+    Return a TelemetryPipeline instance when mode is enabled, else None.
+
+    Never raises. Returns None on any failure so the CLI can continue
+    without telemetry.
+    """
+    if not _is_importable():
+        return None
+    try:
+        from axor_telemetry import TelemetryConfig, build_pipeline as _build
+        cfg = TelemetryConfig.load()
+        if not cfg.enabled:
+            return None
+        return _build(config=cfg, axor_version=axor_version)
+    except Exception:
+        return None
+
+
+def current_mode() -> str:
+    """Resolved mode string ('off' | 'local' | 'remote' | 'unknown')."""
+    if not _is_importable():
+        return "unknown"
+    try:
+        from axor_telemetry import TelemetryConfig
+        return TelemetryConfig.load().mode.value
+    except Exception:
+        return "unknown"
+
+
+def maybe_show_first_run_banner(stream=sys.stderr) -> None:
+    """
+    Print a one-line opt-in banner on the first run of the CLI where
+    telemetry is off. Controlled by:
+      - marker file at ~/.axor/.telemetry_notice_shown (created after shown)
+      - AXOR_NO_BANNER=1 env var to suppress unconditionally
+      - telemetry mode — only shown when OFF
+
+    Safe to call on every startup — second call is a no-op.
+    """
+    if os.environ.get("AXOR_NO_BANNER") == "1":
+        return
+    if not _is_importable():
+        return
+    try:
+        from axor_telemetry import TelemetryConfig
+        cfg = TelemetryConfig.load()
+    except Exception:
+        return
+    if cfg.enabled:
+        return
+    if _MARKER_PATH.is_file():
+        return
+
+    stream.write(
+        "axor: anonymous telemetry is off. "
+        "Run `axor telemetry consent` to help tune the classifier. "
+        "(shown once; suppress with AXOR_NO_BANNER=1)\n"
+    )
+    try:
+        _MARKER_PATH.parent.mkdir(parents=True, exist_ok=True)
+        _MARKER_PATH.write_text("shown\n", encoding="utf-8")
+    except OSError:
+        # Marker is best-effort — missing write permission just means we
+        # may show the banner more than once, not a functional problem.
+        return
+
+
+# ── /telemetry slash command (CLI-local, not governance) ────────────────────
+
+
+def handle_slash(raw: str, stream=sys.stdout) -> int:
+    """
+    Dispatch `/telemetry [on|off|status|preview|consent] ...`.
+
+    Returns a shell-style return code for testability. Prints messages to
+    `stream`. Does not touch the GovernedSession — config writes take effect
+    on next CLI start.
+    """
+    if not _is_importable():
+        stream.write(
+            "telemetry is not installed. Install with: pip install axor-telemetry[core]\n"
+        )
+        return 1
+
+    from axor_telemetry import cli as tcli
+
+    parts = raw.split()
+    if len(parts) <= 1:
+        return tcli.cmd_status(_ns(), stream=stream)
+
+    sub = parts[1].lower()
+    if sub in ("status",):
+        return tcli.cmd_status(_ns(), stream=stream)
+    if sub == "preview":
+        return tcli.cmd_preview(_ns(), stream=stream)
+    if sub == "off":
+        return tcli.cmd_off(_ns(), stream=stream)
+    if sub == "on":
+        ns = _ns(remote="--remote" in parts[2:])
+        return tcli.cmd_on(ns, stream=stream)
+    if sub == "consent":
+        # Interactive consent needs stdin — kept for `python -m axor_telemetry consent`.
+        stream.write(
+            "interactive consent is available via `python -m axor_telemetry consent`.\n"
+            "use `/telemetry on` or `/telemetry on --remote` to opt in without prompts.\n"
+        )
+        return 0
+    stream.write(f"unknown subcommand: {sub}\n")
+    stream.write("usage: /telemetry [status|on [--remote]|off|preview|consent]\n")
+    return 2
+
+
+class _ns:
+    """Minimal argparse.Namespace stand-in for direct cmd_* invocation."""
+
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            setattr(self, k, v)