systemr-cli 1.0.0__py3-none-any.whl

neo/streaming.py

@@ -0,0 +1,315 @@
+"""SSE streaming client for System R chat endpoint.
+
+Implements the Server-Sent Events specification:
+https://html.spec.whatwg.org/multipage/server-sent-events.html
+
+Features:
+- Multi-line data: field concatenation (spec-compliant)
+- Comment filtering (lines starting with :)
+- id: field tracking for reconnection via Last-Event-Id
+- retry: field acknowledgment
+- Reconnection with configurable max retries
+- HTTPS validation on API URL
+- Configurable timeouts and endpoint paths
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator
+
+import httpx
+import structlog
+
+from neo.config import get_api_url
+
+logger = structlog.get_logger(module="streaming")
+
+# ── Configurable constants ──────────────────────────────────────────
+
+MAX_HISTORY_MESSAGES: int = 20
+STREAM_TIMEOUT_SECONDS: float = 180.0
+CONNECT_TIMEOUT_SECONDS: float = 15.0
+BLOCKING_TIMEOUT_SECONDS: float = 120.0
+CHAT_STREAM_PATH: str = "/api/v1/agent/chat/stream"
+CHAT_BLOCKING_PATH: str = "/api/v1/agent/chat"
+CHAT_CONFIRM_PATH: str = "/api/v1/agent/chat/confirm"
+MAX_RETRIES: int = 1
+
+
+@dataclass
+class SSEEvent:
+    """A single Server-Sent Event from the chat stream.
+
+    Attributes:
+        event: Event type (thinking, action, text_delta, confirmation_required, done, error).
+        data: Raw data string (may be multi-line per SSE spec).
+        id: Optional event ID for reconnection tracking.
+        parsed: Data parsed as JSON dict. Falls back to {"text": data} on parse failure.
+    """
+
+    event: str
+    data: str
+    id: str | None = None
+    parsed: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Parse data as JSON on construction."""
+        if self.data:
+            try:
+                self.parsed = json.loads(self.data)
+            except (json.JSONDecodeError, TypeError):
+                self.parsed = {"text": self.data}
+
+
+@dataclass
+class ChatRequest:
+    """Request payload for the chat stream endpoint.
+
+    Attributes:
+        user_input: The user's message (required).
+        session_id: Optional session identifier.
+        model: Optional model override (e.g., "anthropic.claude-opus-4-6").
+        history: Conversation history (truncated to MAX_HISTORY_MESSAGES).
+        profile: PROFILE.md content for context injection.
+        rules: RULES.md content for rule enforcement.
+        research_mode: If True, enriches with news/sentiment data.
+        thinking_visible: If True, streams thinking events to the client.
+    """
+
+    user_input: str
+    session_id: str | None = None
+    model: str | None = None
+    history: list[dict[str, str]] = field(default_factory=list)
+    profile: str | None = None
+    rules: str | None = None
+    daily_context: str | None = None
+    research_mode: bool = False
+    thinking_visible: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to API request payload.
+
+        Returns:
+            Dict ready for JSON serialization. Empty optional fields are omitted.
+        """
+        payload: dict[str, Any] = {"user_input": self.user_input}
+        if self.session_id:
+            payload["session_id"] = self.session_id
+        if self.model:
+            payload["model"] = self.model
+        if self.history:
+            payload["history"] = self.history[-MAX_HISTORY_MESSAGES:]
+        # Merge profile + daily context into a single context field
+        context_parts = []
+        if self.profile:
+            context_parts.append(self.profile)
+        if self.daily_context:
+            context_parts.append(self.daily_context)
+        if context_parts:
+            payload["context"] = "\n\n---\n\n".join(context_parts)
+        if self.rules:
+            payload["rules"] = self.rules
+        payload["research_mode"] = self.research_mode
+        return payload
+
+
+async def stream_chat(
+    request: ChatRequest,
+    access_token: str,
+) -> AsyncIterator[SSEEvent]:
+    """Stream chat responses from the backend via SSE.
+
+    Implements the full SSE parsing specification:
+    - Multi-line data: fields are concatenated with newlines
+    - Comment lines (starting with :) are ignored
+    - id: field tracked for reconnection via Last-Event-Id header
+    - retry: field acknowledged
+    - Reconnection on stream drop (up to MAX_RETRIES)
+
+    Args:
+        request: The chat request payload.
+        access_token: Bearer token for authentication.
+
+    Yields:
+        SSEEvent objects: thinking, action, text_delta, confirmation_required, done, error.
+    """
+    api_url = get_api_url()
+    url = f"{api_url}{CHAT_STREAM_PATH}"
+
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Accept": "text/event-stream",
+        "Cache-Control": "no-cache",
+    }
+
+    last_event_id: str | None = None
+    retries = 0
+
+    while retries <= MAX_RETRIES:
+        try:
+            if last_event_id:
+                headers["Last-Event-Id"] = last_event_id
+
+            timeout = httpx.Timeout(
+                STREAM_TIMEOUT_SECONDS, connect=CONNECT_TIMEOUT_SECONDS,
+            )
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                async with client.stream(
+                    "POST", url, json=request.to_dict(), headers=headers,
+                ) as response:
+                    if response.status_code != 200:
+                        body = await response.aread()
+                        logger.error(
+                            "stream_http_error",
+                            status=response.status_code,
+                            body=body.decode(errors="replace")[:200],
+                        )
+                        yield SSEEvent(
+                            event="error",
+                            data=json.dumps({
+                                "message": (
+                                    f"HTTP {response.status_code}: "
+                                    f"{body.decode(errors='replace')[:200]}"
+                                ),
+                            }),
+                        )
+                        return
+
+                    # SSE spec-compliant parser
+                    event_type = ""
+                    data_lines: list[str] = []
+                    event_id: str | None = None
+
+                    async for line in response.aiter_lines():
+                        # Comment lines — ignore (often keep-alives)
+                        if line.startswith(":"):
+                            continue
+
+                        if line.startswith("event:"):
+                            event_type = line[6:].strip()
+
+                        elif line.startswith("data:"):
+                            # SSE spec: consecutive data: lines concatenated with \n
+                            data_lines.append(line[5:].strip())
+
+                        elif line.startswith("id:"):
+                            event_id = line[3:].strip()
+                            last_event_id = event_id
+
+                        elif line.startswith("retry:"):
+                            pass  # Acknowledged, not used for timing
+
+                        elif line == "":
+                            # Empty line = dispatch event
+                            if data_lines:
+                                data_str = "\n".join(data_lines)
+                                evt = event_type or "text_delta"
+                                yield SSEEvent(
+                                    event=evt, data=data_str, id=event_id,
+                                )
+                            # Reset for next event
+                            event_type = ""
+                            data_lines = []
+                            event_id = None
+
+                    # Flush any remaining event at stream end
+                    if data_lines:
+                        data_str = "\n".join(data_lines)
+                        evt = event_type or "text_delta"
+                        yield SSEEvent(
+                            event=evt, data=data_str, id=event_id,
+                        )
+
+            # Stream completed normally
+            return
+
+        except (httpx.ReadTimeout, httpx.RemoteProtocolError, httpx.ReadError):
+            retries += 1
+            logger.warning("stream_connection_lost", retry=retries)
+            if retries > MAX_RETRIES:
+                yield SSEEvent(
+                    event="error",
+                    data=json.dumps({
+                        "message": "Stream connection lost. Falling back.",
+                    }),
+                )
+                return
+
+        except httpx.ConnectError:
+            logger.error("stream_connect_failed")
+            yield SSEEvent(
+                event="error",
+                data=json.dumps({
+                    "message": "Cannot connect to System R. Check your network.",
+                }),
+            )
+            return
+
+
+async def chat_blocking(
+    request: ChatRequest,
+    access_token: str,
+) -> dict[str, Any]:
+    """Fallback blocking chat call (non-streaming).
+
+    Args:
+        request: The chat request payload.
+        access_token: Bearer token for authentication.
+
+    Returns:
+        Response dict from the API.
+
+    Raises:
+        httpx.HTTPStatusError: On non-2xx responses.
+    """
+    api_url = get_api_url()
+    url = f"{api_url}{CHAT_BLOCKING_PATH}"
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    timeout = httpx.Timeout(
+        BLOCKING_TIMEOUT_SECONDS, connect=CONNECT_TIMEOUT_SECONDS,
+    )
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.post(url, json=request.to_dict(), headers=headers)
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def send_confirmation(
+    confirmation_token: str,
+    approved: bool,
+    access_token: str,
+) -> dict[str, Any]:
+    """Send confirmation response for a pending trade action.
+
+    The backend pauses execution when it encounters a trade action
+    requiring confirmation. It sends a confirmation_required SSE event
+    with a token. The CLI prompts the user, then calls this endpoint
+    to approve or deny. The backend then resumes or cancels.
+
+    Args:
+        confirmation_token: Token from the confirmation_required event.
+        approved: True to approve, False to deny.
+        access_token: Bearer token for authentication.
+
+    Returns:
+        Response dict from the API.
+    """
+    api_url = get_api_url()
+    url = f"{api_url}{CHAT_CONFIRM_PATH}"
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    payload = {
+        "confirmation_token": confirmation_token,
+        "approved": approved,
+    }
+
+    timeout = httpx.Timeout(
+        BLOCKING_TIMEOUT_SECONDS, connect=CONNECT_TIMEOUT_SECONDS,
+    )
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        return resp.json()

neo/types.py

@@ -0,0 +1,109 @@
+"""Financial types for System R CLI.
+
+Rule: Decimal for money, int for counts, str for IDs.
+
+All financial values in System R use decimal.Decimal to prevent
+floating-point rounding errors that can lose real money. These
+types are the foundation — every module that handles prices,
+risk amounts, or percentages imports from here.
+
+Usage:
+    from neo.types import Price, RiskAmount, Quantity, Percentage, to_decimal
+
+    entry = Price("198.50")
+    risk = RiskAmount("1046.80")
+    shares = Quantity(160)
+    risk_pct = Percentage("1.97")
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal, ROUND_HALF_UP
+from typing import Union
+
+# Type aliases for clarity and type checking.
+# All are Decimal — the alias communicates intent.
+Price = Decimal
+RiskAmount = Decimal
+Percentage = Decimal
+
+# Quantity is int — shares, contracts, units. Never fractional.
+Quantity = int
+
+# Rounding contexts
+PRICE_PLACES = Decimal("0.01")       # $198.50
+RISK_PLACES = Decimal("0.01")        # $1046.80
+PCT_PLACES = Decimal("0.01")         # 1.97%
+R_MULTIPLE_PLACES = Decimal("0.01")  # +2.30R
+
+
+def to_decimal(value: Union[str, int, float, Decimal]) -> Decimal:
+    """Convert any numeric value to Decimal safely.
+
+    Handles str, int, float, and Decimal inputs.
+    Float is converted via string to avoid float representation errors.
+
+    Args:
+        value: The numeric value to convert.
+
+    Returns:
+        A Decimal representation of the value.
+
+    Raises:
+        InvalidOperation: If the value cannot be converted.
+    """
+    if isinstance(value, Decimal):
+        return value
+    if isinstance(value, float):
+        # Convert float via string to avoid repr issues
+        # e.g., float 0.1 -> "0.1" -> Decimal("0.1")
+        return Decimal(str(value))
+    return Decimal(value)
+
+
+def round_price(value: Decimal) -> Decimal:
+    """Round a price to 2 decimal places (standard for equities).
+
+    Args:
+        value: The price to round.
+
+    Returns:
+        Price rounded to nearest cent.
+    """
+    return value.quantize(PRICE_PLACES, rounding=ROUND_HALF_UP)
+
+
+def round_risk(value: Decimal) -> Decimal:
+    """Round a risk amount to 2 decimal places.
+
+    Args:
+        value: The risk amount to round.
+
+    Returns:
+        Risk amount rounded to nearest cent.
+    """
+    return value.quantize(RISK_PLACES, rounding=ROUND_HALF_UP)
+
+
+def round_pct(value: Decimal) -> Decimal:
+    """Round a percentage to 2 decimal places.
+
+    Args:
+        value: The percentage to round.
+
+    Returns:
+        Percentage rounded to 2 decimals (e.g., 1.97).
+    """
+    return value.quantize(PCT_PLACES, rounding=ROUND_HALF_UP)
+
+
+def round_r(value: Decimal) -> Decimal:
+    """Round an R-multiple to 2 decimal places.
+
+    Args:
+        value: The R-multiple to round.
+
+    Returns:
+        R-multiple rounded to 2 decimals (e.g., 2.30).
+    """
+    return value.quantize(R_MULTIPLE_PLACES, rounding=ROUND_HALF_UP)

systemr_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: systemr-cli
+Version: 1.0.0
+Summary: System R AI — trading operating system for agents
+Author-email: System R AI <ashim@systemr.ai>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: structlog>=23.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# System R CLI
+
+Trading operating system in your terminal. Like Claude Code, but for trading.
+
+Type natural language. System R runs the full stack — 55 institutional-grade tools, 25 broker adapters, risk engine, G-Score — all from your terminal.
+
+## Install
+
+```bash
+pip install systemr-cli
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/System-R-AI/systemr-neo.git
+cd systemr-neo
+pip install -e .
+```
+
+Requires Python 3.11+.
+
+## Quick Start
+
+```bash
+# Set up your profile
+systemr setup
+
+# Connect to System R
+systemr login
+
+# Start chatting
+systemr chat
+```
+
+That's it. Type in plain English:
+
+```
+you > buy TSLA 2% risk
+```
+
+System R will size the position, check risk, show you the trade card, and ask for confirmation before executing.
+
+## Commands
+
+### Trading
+| Command | Description |
+|---------|-------------|
+| `systemr chat` | Interactive conversation with System R |
+| `systemr size` | Position sizing (G-formula) |
+| `systemr risk` | Pre-trade risk validation |
+| `systemr eval` | System performance analysis (G-Score) |
+| `systemr scan` | Market scanner |
+| `systemr plan` | Trade planning |
+
+### Local
+| Command | Description |
+|---------|-------------|
+| `systemr journal` | Trade journal (add/list/show/edit/export) |
+| `systemr cron` | Scheduled tasks (add/list/remove/run) |
+| `systemr doctor` | Health check and diagnostics |
+| `systemr setup` | Profile and rules wizard |
+
+### Auth
+| Command | Description |
+|---------|-------------|
+| `systemr login` | Connect to System R |
+| `systemr logout` | Disconnect |
+| `systemr whoami` | Show current session |
+
+## Chat Commands
+
+Inside `systemr chat`, use slash commands:
+
+| Command | Action |
+|---------|--------|
+| `/morning` | Morning briefing (4 parallel agents) |
+| `/eod` | End of day review + journal |
+| `/plan` | Plan today's trades |
+| `/portfolio` | Show open positions |
+| `/risk` | Risk dashboard |
+| `/memory <query>` | Search past memories |
+| `/sessions` | List recent sessions |
+| `/cron` | Manage scheduled tasks |
+| `/permissions` | View/switch safety profile |
+| `/remember <text>` | Save a memory |
+| `/model <name>` | Switch LLM model |
+| `/credits` | Session credit usage |
+| `/help` | All commands |
+
+## Safety
+
+Three-tier confirmation protocol:
+
+- **AUTO** — Read-only actions (quotes, analysis, calculations)
+- **CONFIRM** — Trade actions (place/cancel/modify order) — show details, y/n
+- **DOUBLE_CONFIRM** — Destructive actions (kill switch) — type "KILL"
+
+Permission profiles: `paper` (max safety), `standard` (default), `experienced` (relaxed stops).
+
+## Architecture
+
+```
+~/.systemr/
+  PROFILE.md          # Trader identity, risk params
+  RULES.md            # Hard/soft rules + standing orders
+  auth.json           # API credentials (chmod 600)
+  config.json         # Settings, model config
+  journal.db          # SQLite trade journal
+  memory/
+    MEMORY.md         # Index
+    YYYY-MM-DD.md     # Daily trading logs
+    *.md              # Lessons, notes, violations
+  sessions/
+    last_session.json # Resume state
+  cron/
+    jobs.json         # Scheduled tasks
+    runs/             # Run history (JSONL)
+```
+
+All data stays on your machine. The backend (`agents.systemr.ai`) processes requests — your profile, rules, and journal never leave your disk.
+
+## Backend
+
+System R CLI connects to `agents.systemr.ai`:
+
+- 55 MCP tools (sizing, risk, intelligence, planning, behavioral)
+- 25 broker/exchange adapters
+- 187 domain services
+- Per-agent encryption (AES-128-CBC)
+- Multi-model LLM via AWS Bedrock (Claude, GPT, Nova)
+- Compute credit billing (USDC, SOL, OSR)
+
+## Development
+
+```bash
+git clone https://github.com/System-R-AI/systemr-neo.git
+cd systemr-neo
+pip install -e ".[dev]"
+pytest
+```
+
+### Rules
+
+- Decimal for all money — never float
+- structlog only — zero `print()`
+- Additive-only — never remove/rename
+- Tests for every module
+
+### Stats
+
+- 33 source files, ~8,800 lines
+- 206 tests passing
+- Zero bare `print()` statements
+- Python 3.11+
+
+## Links
+
+- [systemr.ai](https://systemr.ai) — Documentation
+- [agents.systemr.ai](https://agents.systemr.ai) — API
+- [app.systemr.ai](https://app.systemr.ai) — Portal
+
+Built by [Ashim Nandi](https://ashimnandi.com) and Shannon at [System R AI](https://systemr.ai).

systemr_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+neo/__init__.py,sha256=tfzk1-_akK5JhODp5y_JU5oWNX0sBADJckoZy1aDJi8,89
+neo/__main__.py,sha256=jgcHytKsLPyX3dO6FyuxJqV_NunRjsR0TbmURtwyEJs,72
+neo/auth.py,sha256=hyfCHiusymLl_ZT-x1hdPLp-BWlIe0PjoxPSEBZRmcc,6056
+neo/cli.py,sha256=c14ISxc9RJWolO-pAsImhKpvX8OIBo4_oqjEx9pdt_o,6379
+neo/client.py,sha256=OcZgXBynuoaUU8B2MLaoPl_t0DgF1TquRDkC1r3_jzI,2102
+neo/config.py,sha256=NBwWUg48JHhLqIOONpJOxwKI279TINSH-cVh4f3WJc0,2137
+neo/confirmation.py,sha256=2elJIZu9pUTyabnrHywolFmXidMa78BNJDjWf2Y4vYw,10628
+neo/credits.py,sha256=VINRtrMDvQLwnFofNarGfVuKkMrvIbfGW7fcbGcYRm0,3211
+neo/cron.py,sha256=RRbvAhY2rng2RyuW5Qfqz9s63Pompq6VbxJIbLqyt2E,9806
+neo/hooks.py,sha256=ifeyuwCrQhlu4mDodymu5fFEK9Cwd9LYEKX2IQOvwBQ,4903
+neo/logging.py,sha256=vU_kWAZs6BQg8QfepRfau0Yeu8AALUdU-oOwH_P8nMs,1707
+neo/model_failover.py,sha256=oxxG0xfoY_5s5plrd0fX9itfvk-avxuWYApPH_yZH1I,5957
+neo/orchestrator.py,sha256=WmOkMtOS3Bqr1nChsPuVQ6KcfF9BZFRcr-n2FKq9JuM,9718
+neo/profile.py,sha256=L9vSsELJwPmqEu3sNoBa3ALZbm9fVRtYlXf49c_nlrA,14985
+neo/store.py,sha256=Ws8ZOa0A9QbKQFI87afgEvxcTkcXjv9FDAyV6W4H_1w,13189
+neo/streaming.py,sha256=ot2jkfq0fj4KPpjkJbQCijCQFFZWIPh_tMWXyaszfVg,11009
+neo/types.py,sha256=9hVIylz_yl9r8dnWg2OmXCpfZiggIR2evi6E067EQ7o,2922
+neo/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neo/commands/auth_commands.py,sha256=FxhLmYtMvQ8jrMu6VZh7IWYcArJ3pkJYCpDCDbX8ObA,11455
+neo/commands/chat_commands.py,sha256=E0kSUDRoF3pT6qo5vPSy_Zqi-BpBZ_oDA3kf1zVImr0,35003
+neo/commands/cron_commands.py,sha256=RhXRaj-MhYrZierQAzQ3Iv67x4cj1V_RVQwgb8FdYfg,5682
+neo/commands/doctor_command.py,sha256=Ammu2R55fdLrtNMgrnE8W2eR4J2R8lY2YkJHsiIeSk4,6088
+neo/commands/eval_commands.py,sha256=CPyy910ZEl3_eOLeGqesWtnuuwnWiatdilrPbpdhToQ,2385
+neo/commands/journal_commands.py,sha256=rKowVMlkfWT3hU9gQshfnDcyeSikvSecyd5wB-CN7NA,6695
+neo/commands/plan_commands.py,sha256=Qp7bCGnu_1Ti1M5TG6s2SAEy9sSHrXV0Q_TRqNcXV4g,2897
+neo/commands/risk_commands.py,sha256=aU6bNHBbVaDreXAtLOYXBEWgHRIJrucAQuuxmaUJNNE,2416
+neo/commands/scan_commands.py,sha256=nvwT_FpknmgZsnzmL_OcHYDuKaNmycP8Pd-w5EzDiVo,2014
+neo/commands/size_commands.py,sha256=wbhWkDDwEkXvPTTRq-nYTdEwAI7XUQsPDM5N5y3a118,2268
+neo/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neo/display/chat_renderer.py,sha256=FlDDZIingiowYPDmaWkGoBOEV6KZNUGVhmIX7qfTa2k,3681
+neo/display/formatters.py,sha256=lPUsYHVDORa-q0HwfuwOx83npQfPojO1ACsU3lDpIFo,2808
+neo/display/tables.py,sha256=lPFYIeUnJSCNGeuOR3f2GFcEUOg0fKiSf4meOk2p18Q,1625
+neo/display/theme.py,sha256=gBCXAAMZwYQV-Y-hClCsFcSwpVUEV3NQaWSxZOcC8k8,4941
+systemr_cli-1.0.0.dist-info/METADATA,sha256=85BFL54avhpV4oWhX9Ejsm0YHBYJXEPFKXc1OvLeOec,5338
+systemr_cli-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+systemr_cli-1.0.0.dist-info/entry_points.txt,sha256=KBhZic5uYphEuxbD5KCmJU2f770dxHaCFxPK_HGwFkA,58
+systemr_cli-1.0.0.dist-info/RECORD,,

systemr_cli-1.0.0.dist-info/WHEEL

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

systemr_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+neo = neo.cli:cli
+systemr = neo.cli:cli