saurix 0.1.0__tar.gz

saurix-0.1.0/.github/workflows/publish.yaml

@@ -0,0 +1,36 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          twine upload dist/*

saurix-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+# Bytecode and Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build and packaging artifacts
+build/
+dist/
+wheels/
+*.egg-info/
+.eggs/
+*.egg
+pip-wheel-metadata/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Test and type-checker caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+.coverage
+.coverage.*
+htmlcov/
+
+# Tooling and editor folders
+.python-version
+.idea/
+.vscode/
+
+# Local runtime files
+*.log
+
+# Generated artifacts
+tmp/
+
+
+# Other
+saurix.graph.json
+saurix.html

saurix-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anis M
+
+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.

saurix-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: saurix
+Version: 0.1.0
+Summary: Interactive CLI that indexes polyglot repositories into a queryable knowledge graph for AI agents
+Project-URL: Homepage, https://github.com/anismabaziz/saurix
+Project-URL: Repository, https://github.com/anismabaziz/saurix
+Project-URL: Issues, https://github.com/anismabaziz/saurix/issues
+Author-email: Anis B <anisbaziz.sub@gmail.com>
+License-File: LICENSE
+Keywords: ai-agents,architecture,knowledge-graph,mcp,static-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.1.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: tree-sitter-languages>=1.10.2
+Requires-Dist: tree-sitter<0.22,>=0.21
+Description-Content-Type: text/markdown
+
+# Saurix
+
+Saurix is an interactive knowledge graph engine that transforms complex codebases into a queryable, 3D-visualizable map. It is designed to be the **Symbolic Intelligence Layer** for modern AI coding agents.
+
+## Why Saurix for AI Agents?
+
+Saurix solves the "Context Window" problem for LLMs by providing a structured representation of code that is superior to keyword search:
+
+- **Structural Awareness**: Understands `CALLS`, `INHERITS`, and `IMPORTS` relationships rather than just raw text.
+- **Context Efficiency**: Agents can query specific subgraphs, receiving only the architectural context they need, drastically reducing token usage.
+- **Blast Radius Analysis**: Built-in `impact` analysis allows agents to calculate the transitive side effects of a proposed change before making it.
+- **Native MCP Support**: Built on the **Model Context Protocol**, allowing AI agents to treat the repository graph as an extension of their own memory.
+
+See [docs/agent-lifecycle.md](docs/agent-lifecycle.md) for a step-by-step walkthrough of how an AI agent uses these capabilities.
+
+---
+
+## 1) Core Mission
+
+- **Knowledge Extraction**: Turn local or GitHub repositories into a structured graph of symbols and relationships.
+- **Agent Infrastructure**: Expose high-level tools (MCP) for autonomous agents to navigate complex architectures.
+- **Fast Navigation**: Answer questions about dependencies, callers, and impact analysis in milliseconds.
+- **Modular Architecture**: Built for extensibility across languages and tools.
+
+---
+
+## 2) Architecture
+
+Saurix follows a clean, domain-driven modular structure:
+
+```mermaid
+flowchart TD
+    subgraph core
+        A[Indexing] --> B[Graph Store]
+        B --> C[Cache]
+        D[Source Prep] --> A
+    end
+    subgraph analysis
+        E[Extractors] --> A
+        F[Python] --> E
+        G[TypeScript] --> E
+        H[Go/Java/Stub] --> E
+    end
+    subgraph discovery
+        I[Search/Query] --> B
+        J[Traversal/Impact] --> B
+        K[Visualizer] --> B
+    end
+    subgraph agents
+        L[MCP Server] --> discovery
+        L --> core
+    end
+    subgraph cli
+        M[Interactive Shell] --> discovery
+        M --> core
+    end
+```
+
+- **`saurix.core`**: Root indexing orchestration, graph models, and incremental caching.
+- **`saurix.analysis`**: Language-specific AST and Tree-sitter extractors.
+- **`saurix.discovery`**: Relationship discovery, search logic, and visualization generation.
+- **`saurix.agents.mcp`**: Tooling interface for AI agents.
+- **`saurix.infra`**: Centralized configuration and structured logging.
+
+---
+
+## Setup & Installation
+
+Choose the path that fits your workflow:
+
+### A) The "Power User" Path (Global & Project-Native)
+Recommended for using Saurix as a permanent tool for your own development projects.
+
+1. **Install Globally**:
+   ```bash
+   pip install -e .
+   ```
+2. **Initialize Any Project**:
+   ```bash
+   cd /path/to/your/project
+   saurix init
+   ```
+   *This command indexes your project, creates a local 3D dashboard (`saurix.html`), and generates your MCP config in one step.*
+
+### B) The "Developer" Path (Standalone)
+Recommended if you want to contribute to Saurix or run it in isolation using `uv`.
+
+1. **Clone & Setup**:
+   ```bash
+   git clone https://github.com/anismabaziz/saurix.git
+   cd saurix
+   uv sync
+   ```
+2. **Run via uv**:
+   ```bash
+   uv run saurix
+   ```
+
+### Running the MCP Server
+
+Expose graph tools to AI agents (e.g., Claude Desktop, Cursor):
+
+```bash
+saurix-mcp
+```
+
+---
+
+## 4) Interactive Commands
+
+| Command          | Description                                           |
+| ---------------- | ----------------------------------------------------- |
+| `init`           | Zero-config setup for the current project             |
+| `index <source>` | Index a local path or GitHub URL                      |
+| `stats`          | Show graph statistics and extraction coverage         |
+| `find <query>`   | Fuzzy search symbols by name or ID                    |
+| `callers <sym>`  | List symbols calling the target                       |
+| `path <A> <B>`   | Find shortest directed path between two symbols       |
+| `impact <sym>`   | Estimate blast radius of a change                     |
+| `visual`         | Generate a hybrid 2D/3D knowledge graph visualization |
+| `export`         | Export to GraphML or Neo4j CSV                        |
+
+---
+
+## 5) AI Agent Integration (MCP)
+
+Saurix is optimized for agentic workflows. It exposes tools that help agents understand:
+
+1. **Context Discovery**: `find_symbol` and `related_files`.
+2. **Behavioral Mapping**: `callers` and `path_between`.
+3. **Risk Assessment**: `impact_of_symbol`.
+
+Configure your agent with the `saurix-mcp` entry point. Once configured, the AI client (e.g., Claude Desktop) will automatically manage the server lifecycle—starting it in the background when needed and stopping it when the app closes. No manual terminal execution is required.
+
+---
+
+## 6) Development
+
+### Running Tests
+
+```bash
+uv run pytest
+```
+
+### Testing the MCP Server
+
+You can test the MCP integration without a full IDE using the **MCP Inspector**:
+
+1. **Install the Inspector**: `npm install -g @modelcontextprotocol/inspector`
+2. **Run the Server**: `npx @modelcontextprotocol/inspector uv run saurix-mcp`
+3. **Interact**: Open `http://localhost:5173`, click **Connect**, and use the **Call Tool** tab.
+
+For step-by-step setup (Claude Desktop, Cursor, OpenCode), simply run `saurix init` in your project folder.
+
+### Roadmap
+
+- [ ] **Rich Cross-Language Resolution**: Better linking across monorepos.
+- [ ] **LLM Integration**: Optional LLM-powered relationship refinement.
+- [ ] **Remote Store**: Support for remote graph databases (Neo4j/Memgraph).
+- [ ] **Dynamic Language Support**: Plug-and-play extractor modules.
+
+---
+
+_Saurix is built for the era of autonomous coding._

saurix-0.1.0/README.md

@@ -0,0 +1,164 @@
+# Saurix
+
+Saurix is an interactive knowledge graph engine that transforms complex codebases into a queryable, 3D-visualizable map. It is designed to be the **Symbolic Intelligence Layer** for modern AI coding agents.
+
+## Why Saurix for AI Agents?
+
+Saurix solves the "Context Window" problem for LLMs by providing a structured representation of code that is superior to keyword search:
+
+- **Structural Awareness**: Understands `CALLS`, `INHERITS`, and `IMPORTS` relationships rather than just raw text.
+- **Context Efficiency**: Agents can query specific subgraphs, receiving only the architectural context they need, drastically reducing token usage.
+- **Blast Radius Analysis**: Built-in `impact` analysis allows agents to calculate the transitive side effects of a proposed change before making it.
+- **Native MCP Support**: Built on the **Model Context Protocol**, allowing AI agents to treat the repository graph as an extension of their own memory.
+
+See [docs/agent-lifecycle.md](docs/agent-lifecycle.md) for a step-by-step walkthrough of how an AI agent uses these capabilities.
+
+---
+
+## 1) Core Mission
+
+- **Knowledge Extraction**: Turn local or GitHub repositories into a structured graph of symbols and relationships.
+- **Agent Infrastructure**: Expose high-level tools (MCP) for autonomous agents to navigate complex architectures.
+- **Fast Navigation**: Answer questions about dependencies, callers, and impact analysis in milliseconds.
+- **Modular Architecture**: Built for extensibility across languages and tools.
+
+---
+
+## 2) Architecture
+
+Saurix follows a clean, domain-driven modular structure:
+
+```mermaid
+flowchart TD
+    subgraph core
+        A[Indexing] --> B[Graph Store]
+        B --> C[Cache]
+        D[Source Prep] --> A
+    end
+    subgraph analysis
+        E[Extractors] --> A
+        F[Python] --> E
+        G[TypeScript] --> E
+        H[Go/Java/Stub] --> E
+    end
+    subgraph discovery
+        I[Search/Query] --> B
+        J[Traversal/Impact] --> B
+        K[Visualizer] --> B
+    end
+    subgraph agents
+        L[MCP Server] --> discovery
+        L --> core
+    end
+    subgraph cli
+        M[Interactive Shell] --> discovery
+        M --> core
+    end
+```
+
+- **`saurix.core`**: Root indexing orchestration, graph models, and incremental caching.
+- **`saurix.analysis`**: Language-specific AST and Tree-sitter extractors.
+- **`saurix.discovery`**: Relationship discovery, search logic, and visualization generation.
+- **`saurix.agents.mcp`**: Tooling interface for AI agents.
+- **`saurix.infra`**: Centralized configuration and structured logging.
+
+---
+
+## Setup & Installation
+
+Choose the path that fits your workflow:
+
+### A) The "Power User" Path (Global & Project-Native)
+Recommended for using Saurix as a permanent tool for your own development projects.
+
+1. **Install Globally**:
+   ```bash
+   pip install -e .
+   ```
+2. **Initialize Any Project**:
+   ```bash
+   cd /path/to/your/project
+   saurix init
+   ```
+   *This command indexes your project, creates a local 3D dashboard (`saurix.html`), and generates your MCP config in one step.*
+
+### B) The "Developer" Path (Standalone)
+Recommended if you want to contribute to Saurix or run it in isolation using `uv`.
+
+1. **Clone & Setup**:
+   ```bash
+   git clone https://github.com/anismabaziz/saurix.git
+   cd saurix
+   uv sync
+   ```
+2. **Run via uv**:
+   ```bash
+   uv run saurix
+   ```
+
+### Running the MCP Server
+
+Expose graph tools to AI agents (e.g., Claude Desktop, Cursor):
+
+```bash
+saurix-mcp
+```
+
+---
+
+## 4) Interactive Commands
+
+| Command          | Description                                           |
+| ---------------- | ----------------------------------------------------- |
+| `init`           | Zero-config setup for the current project             |
+| `index <source>` | Index a local path or GitHub URL                      |
+| `stats`          | Show graph statistics and extraction coverage         |
+| `find <query>`   | Fuzzy search symbols by name or ID                    |
+| `callers <sym>`  | List symbols calling the target                       |
+| `path <A> <B>`   | Find shortest directed path between two symbols       |
+| `impact <sym>`   | Estimate blast radius of a change                     |
+| `visual`         | Generate a hybrid 2D/3D knowledge graph visualization |
+| `export`         | Export to GraphML or Neo4j CSV                        |
+
+---
+
+## 5) AI Agent Integration (MCP)
+
+Saurix is optimized for agentic workflows. It exposes tools that help agents understand:
+
+1. **Context Discovery**: `find_symbol` and `related_files`.
+2. **Behavioral Mapping**: `callers` and `path_between`.
+3. **Risk Assessment**: `impact_of_symbol`.
+
+Configure your agent with the `saurix-mcp` entry point. Once configured, the AI client (e.g., Claude Desktop) will automatically manage the server lifecycle—starting it in the background when needed and stopping it when the app closes. No manual terminal execution is required.
+
+---
+
+## 6) Development
+
+### Running Tests
+
+```bash
+uv run pytest
+```
+
+### Testing the MCP Server
+
+You can test the MCP integration without a full IDE using the **MCP Inspector**:
+
+1. **Install the Inspector**: `npm install -g @modelcontextprotocol/inspector`
+2. **Run the Server**: `npx @modelcontextprotocol/inspector uv run saurix-mcp`
+3. **Interact**: Open `http://localhost:5173`, click **Connect**, and use the **Call Tool** tab.
+
+For step-by-step setup (Claude Desktop, Cursor, OpenCode), simply run `saurix init` in your project folder.
+
+### Roadmap
+
+- [ ] **Rich Cross-Language Resolution**: Better linking across monorepos.
+- [ ] **LLM Integration**: Optional LLM-powered relationship refinement.
+- [ ] **Remote Store**: Support for remote graph databases (Neo4j/Memgraph).
+- [ ] **Dynamic Language Support**: Plug-and-play extractor modules.
+
+---
+
+_Saurix is built for the era of autonomous coding._

saurix-0.1.0/demo-mcp.md

@@ -0,0 +1,130 @@
+# MCP Demo (Saurix)
+
+This demo shows a simple MCP workflow with 5 tool calls and expected response shapes.
+
+## Prerequisites
+
+- Run `uv sync`
+- Start MCP server: `saurix-mcp`
+
+## 1) Index a repo
+
+Tool call:
+
+```json
+{
+  "tool": "index_repo",
+  "arguments": {
+    "source": "https://github.com/anismabaziz/saurix"
+  }
+}
+```
+
+Expected response shape:
+
+```json
+{
+  "ok": true,
+  "data": {
+    "graph_path": ".../tmp/saurix.graph.json",
+    "source_kind": "github:anismabaziz/saurix",
+    "scanned_files": 30,
+    "indexed_files": 30,
+    "stats": { "nodes": 0, "edges": 0 }
+  },
+  "meta": { "duration_ms": 0 }
+}
+```
+
+## 2) Read graph stats
+
+Tool call:
+
+```json
+{
+  "tool": "stats",
+  "arguments": {
+    "graph": "tmp/saurix.graph.json"
+  }
+}
+```
+
+Expected response includes:
+
+- `confidence_counts`
+- `confidence_percentages`
+- `extraction_coverage`
+
+## 3) Find a symbol
+
+Tool call:
+
+```json
+{
+  "tool": "find_symbol",
+  "arguments": {
+    "graph": "tmp/saurix.graph.json",
+    "query": "find_symbol",
+    "limit": 10
+  }
+}
+```
+
+Expected response:
+
+```json
+{
+  "ok": true,
+  "data": [
+    {
+      "id": "python://saurix.query.basic:find_symbol",
+      "type": "function",
+      "name": "find_symbol",
+      "file": "saurix/query/basic.py"
+    }
+  ],
+  "meta": { "count": 1, "duration_ms": 0 }
+}
+```
+
+## 4) Find path between symbols
+
+Tool call:
+
+```json
+{
+  "tool": "path_between",
+  "arguments": {
+    "graph": "tmp/saurix.graph.json",
+    "source": "python://saurix.cli.commands:cmd_find",
+    "target": "python://saurix.query.basic:find_symbol",
+    "max_depth": 12
+  }
+}
+```
+
+Expected response:
+
+- `ok: true`
+- `data`: list of path steps (`step`, `edge`, `id`, `type`, `name`)
+
+## 5) Impact analysis
+
+Tool call:
+
+```json
+{
+  "tool": "impact_of_symbol",
+  "arguments": {
+    "graph": "tmp/saurix.graph.json",
+    "symbol": "python://saurix.query.basic:find_symbol",
+    "depth": 3,
+    "limit": 50
+  }
+}
+```
+
+Expected response:
+
+- `ok: true`
+- `data`: reverse-neighborhood rows (`distance`, `via`, `id`, `type`, `name`, `file`)

saurix-0.1.0/docs/agent-lifecycle.md

@@ -0,0 +1,53 @@
+# The Lifecycle of an AI Agent using Saurix
+
+This walkthrough illustrates how an AI Agent (like Claude or Antigravity) uses Saurix to solve a real-world task: **"Modify the data persistence layer to support PostgreSQL."**
+
+---
+
+### Phase 0: Triggering a Smart Workflow (Optional)
+Before the agent even looks at the code, the user can jumpstart the process using a pre-defined **MCP Prompt**.
+- **User Action**: Selects the `repo_onboarding` prompt.
+- **Agent Instruction**: "You are an expert architect. Index the repo, get stats, and explain the entry points."
+- **Benefit**: The agent is immediately put into a "High-Level Architecture" mindset without manual prompting.
+
+### Phase 1: Environmental Awareness (The Bird's Eye View)
+The agent is dropped into a 50,000-line repository it has never seen.
+- **Agent Action**: Calls `saurix.stats()`.
+- **Knowledge Gained**: "Okay, this is 80% Python with 450 nodes. It's a medium-sized OO project."
+- **Next Step**: The agent uses `find_symbol(query="persistence")` to locate the `DatabaseStore` class in `core/db.py`.
+- **Benefit**: The agent doesn't have to guess where the "important" files are.
+
+### Phase 2: Navigation (Finding the Entry Point)
+The agent needs to find where the database logic is actually used.
+- **Agent Action**: Calls `saurix.find_symbol(query="Database")`.
+- **Knowledge Gained**: It finds `core.persistence:SQLiteStore` and `core.persistence:BaseStore`.
+- **Benefit**: Instant pinpointing of relevant classes without reading irrelevant "database" mentions in documentation or logs.
+
+### Phase 3: Relationship Mapping (Connecting the Dots)
+The agent needs to know how the rest of the app interacts with the database.
+- **Agent Action**: Calls `saurix.path_between(source="cli.app:main", target="core.persistence:SQLiteStore")`.
+- **Knowledge Gained**: "The flow is: `main` -> `CommandDispatcher` -> `RepositoryIndexer` -> `GraphStore` -> `SQLiteStore`."
+- **Benefit**: The agent now understands the **Data Flow** of the entire application across 5 different files.
+
+### Phase 4: Risk Assessment (The "Blast Radius")
+The agent is about to change the `BaseStore` interface to support PostgreSQL.
+- **Agent Action**: Calls `saurix.impact_of_symbol(symbol="core.persistence:BaseStore")`.
+- **Knowledge Gained**: "Wait, if I change this interface, I will break 12 different tests and 3 exporters I didn't know existed."
+- **Benefit**: The agent identifies potential regressions **before** it even starts writing code.
+
+### Phase 5: Implementation & Verification
+The agent writes the new `PostgresStore` class.
+- **Agent Action**: Calls `saurix.index_repo(source=".")`.
+- **Knowledge Gained**: The agent verifies that the new class is correctly "seen" by the graph and that its inheritance edges to `BaseStore` are active.
+- **Benefit**: Final structural verification that the new code is correctly integrated into the system.
+
+---
+
+### Comparison: With vs. Without Saurix
+
+| Feature | Without Saurix | With Saurix |
+| :--- | :--- | :--- |
+| **Discovery** | Reads 20 files (Slow, Expensive) | `stats()` + `find()` (Instant, Cheap) |
+| **Data Flow** | Manually traces imports (Error-prone) | `path_between()` (Absolute precision) |
+| **Safety** | "Guess" what might break | `impact()` (Transitive dependencies) |
+| **Confidence** | Low (Missing context) | High (Full architectural map) |

saurix-0.1.0/docs/assets/README.md

@@ -0,0 +1,14 @@
+# Demo Assets Placeholder
+
+Add your screenshots/GIF here and keep these filenames for README references:
+
+- `cli-workflow.png`
+- `visual-workflow.png`
+- `mcp-workflow.png`
+- `saurix-demo.gif`
+
+Suggested capture flow:
+
+1. CLI: `index`, `stats`, `find`, `impact`
+2. Visual UI: search + edge filters + path highlight
+3. MCP: `index_repo` -> `find_symbol` -> `path_between` -> `impact_of_symbol`

saurix-0.1.0/docs/benchmarks.md

@@ -0,0 +1,28 @@
+# Saurix Performance Benchmarks
+
+This report is automatically generated by `scripts/benchmark_suite.py`.
+
+## Indexing & Storage Performance
+Comparison of cold-start indexing vs. incremental re-indexing, and resulting graph size.
+
+| Repository | Language | Files | Full Index | Incremental | Speedup | Graph Size |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| `pallets/flask` | python | 83 | 0.22s | 0.10s | 2.3x | 2211.7 KB |
+| `axios/axios` | typescript | 219 | 0.16s | 0.05s | 3.1x | 546.3 KB |
+| `django/django` | python | 3015 | 9.38s | 4.93s | 1.9x | 103386.3 KB |
+| `facebook/react` | typescript | 4366 | 8.82s | 0.90s | 9.7x | 10263.7 KB |
+| `kubernetes/kubernetes` | go | 17015 | 104.13s | 30.34s | 3.4x | 484022.7 KB |
+
+## Query & Graph Complexity
+Measurements of internal graph density and response time for complex symbolic queries.
+
+| Repository | Nodes | Edges | Density | Impact Query (D3) |
+| :--- | :--- | :--- | :--- | :--- |
+| `pallets/flask` | 2095 | 5340 | 2.55 | 0.0 ms |
+| `axios/axios` | 456 | 1259 | 2.76 | 0.0 ms |
+| `django/django` | 64431 | 238181 | 3.70 | 0.0 ms |
+| `facebook/react` | 8218 | 16436 | 2.00 | 0.1 ms |
+| `kubernetes/kubernetes` | 124795 | 1278966 | 10.25 | 0.0 ms |
+
+---
+*Benchmarks performed on: macOS / Apple Silicon.*

saurix-0.1.0/main.py

@@ -0,0 +1,5 @@
+from saurix.cli import run
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())