mcp-osiris 0.1.0__py3-none-any.whl

mcp_osiris-0.1.0.dist-info/METADATA

@@ -0,0 +1,384 @@
+Metadata-Version: 2.5
+Name: mcp-osiris
+Version: 0.1.0
+Summary: OSIRIS — context engine cache-aware pour agents IA (serveur MCP local, provider-agnostic).
+Project-URL: Homepage, https://github.com/MlkBlk-IT/osiris
+Project-URL: Repository, https://github.com/MlkBlk-IT/osiris
+Project-URL: Issues, https://github.com/MlkBlk-IT/osiris/issues
+Project-URL: Changelog, https://github.com/MlkBlk-IT/osiris/blob/main/CHANGELOG.md
+Author: Malik Belkacemi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,context-engine,cost,mcp,memory,osiris,prompt-cache
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tiktoken>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/MlkBlk-IT/osiris/main/docs/mlkblk-banner-v2.svg" width="100%" alt="OSIRIS — Cache-aware context engine & state governor for AI agents" />
+</p>
+
+# OSIRIS
+
+**Cache-aware context engine & state governor for AI agents.** Standard MCP server, local-first, independent of any model provider.
+
+> OSIRIS makes AI agents cheaper, faster, and more reliable: fewer tokens, fewer loops, zero unnecessary tools, and zero loss of context.
+
+OSIRIS does not replace your other MCP servers (filesystem, Git, GitHub, shell, browser…). It **coexists** alongside them and drastically cuts what they cost in prompt context.
+
+---
+
+## 1. The Core Architectural Constraint
+
+An MCP server **never sees** the final prompt assembled by the client host. It only sees what the agent sends to it. Therefore, OSIRIS cannot:
+
+| What we would want | What a standard MCP server can actually do |
+|---|---|
+| Write directly into the prompt | Produce canonical state and **have the agent carry it** |
+| Erase past conversation turns | Decide what to externalize **for future turns** |
+| Hide another MCP server's tools | **Recommend** via Tool Compass |
+| Hard-cap prompt tokens | Block an **action** (invariants, budget enforcement) |
+
+The promise is honest: OSIRIS provides **stable state and an enforceable safety contract**, not a client prompt builder.
+
+---
+
+## 2. Sealed Manifest — The Core Design
+
+`osiris.plan` returns a deterministic block (~120 tokens) that the agent carries at a fixed position in its context window:
+
+```text
+OSIRIS/1 task=7c3f obj="fix PowerShell profile bug" plan=3/7
+inv=4 files=6 refs=9 dec=2 budget=ok
+SEAL=sha256:3f9a1c…c21b
+```
+
+The `SEAL` is a SHA256 digest of stable zones. The agent passes it on every turn to `osiris.observe`: OSIRIS recomputes and detects any state drift immediately.
+
+**This is OSIRIS's passive transport**: even if the agent stops calling tools, it carries the essential state cleanly.
+
+### Three Hashes Because Prompt Cache is Prefix-Based
+
+```
+head_hash   = sha256(system_head ‖ rules)                       immutable
+zoneB_hash  = sha256(objective ‖ global_plan ‖ tool_contract)   quasi-stable
+tail_hash   = sha256(constraints ‖ pinned_decisions)           append-only
+prefix_hash = sha256(head_hash ‖ zoneB_hash)                   ← cached prefix
+zoneA_hash  = sha256(head_hash ‖ tail_hash)                    ← full ZONE A
+```
+
+| Change | Verdict | Cache Cost |
+|---|---|---|
+| `head_hash` | **CRITICAL DRIFT** | Full re-prefill |
+| `zoneB_hash` | Minor drift | Re-prefill delta only |
+| `tail_hash` (append) | **Normal growth** | Re-prefill delta only |
+| Pinned item **rewritten** | **CRITICAL DRIFT (semantic)** | Cache intact, task state corrupted |
+
+> **Appending** a constraint or decision changes `tail_hash` but **not** `prefix_hash`: the prompt cache holds, only the new tokens are prefilled.
+>
+> **Rewriting** a pinned decision is explicitly caught: OSIRIS checks collection identity, flagging a semantic break (`semantic_break: true`, `cause: pinned_rewrite`).
+
+---
+
+## 3. The 6 MCP Tools
+
+Access footprint: **1,019 tokens** of schemas and descriptions in model context (measured via `bench/run_bench.py`). Paid on task start, amortized across the session — pays off on the very first turn with ≥800 token payloads.
+
+| Tool | Role | Typical Response |
+|---|---|---|
+| `osiris.plan` | Start / update / resume / status of a task; produces sealed manifest | ~160 tok |
+| `osiris.precheck` | Authorize or deny an action (invariants, budget, deduplication) | ~70 tok |
+| `osiris.observe` | Log actions, loop detection, offload large data, update memory | ~50 tok |
+| `osiris.recall` | Rehydrate refs (**server-side filtered**: grep, range, outline) | variable |
+| `osiris.checkpoint` | Snapshot, resume, completion report, reversible compaction | ~80 tok |
+| `osiris.handoff` | Executable delegation contracts and structured results | ~200 tok |
+
+`osiris.observe` combines logging, loop protection, payload externalization, memory registry, and automated pruning in a single call so the agent always reports back seamlessly.
+
+### Extended Operations
+
+| Call | Behavior |
+|---|---|
+| `osiris.observe(kind="dropped", result=<ref>)` | **Drop receipt**: agent confirms payload was evicted from prompt → token savings are **proven** and credited |
+| `osiris.observe(kind="head"\|"contract", result=…)` | Records system prompt head / client contract and detects cache-busting volatile tokens (timestamps, UUIDs) |
+| `osiris.recall(op="grep"\|"range"\|"head"\|"tail"\|"outline"\|"aggregate"\|"jsonl")` | **Server-side filtering**: only requested matches enter the context window |
+| `osiris.plan(mode="status")` | Context pressure breakdown (measured vs declared vs unknown) |
+| `osiris.checkpoint(mode="compact"\|"trim"\|"clear")` | Reversible session compaction preparation |
+| `osiris.precheck` → `suggest_alternative` | Active collision resolution for duplicate operations |
+
+### Resources & Prompts
+
+- `osiris://task/{task_id}/manifest` — Active zones, drift status, objective
+- `osiris://task/{task_id}/status` — Real-time context pressure
+- `osiris://ref/{ref}` — Raw byte content of any referenced payload
+- Prompt `osiris/task-resume` — Clean agent recovery template after crashes
+
+---
+
+## 4. Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  Agent (Claude Code, Cursor, MiniMax Code, Codex, Cline…)   │
+│  Context: system │ tools │ OSIRIS MANIFEST │ history         │
+└───────────────────────────┬──────────────────────────────────┘
+                            │  MCP stdio — 6 tools, ~1,019 tok schema
+                            ▼
+┌──────────────────────────────────────────────────────────────┐
+│  osiris-mcp  (server.py)                                     │
+│  plan · precheck · observe · recall · checkpoint · handoff   │
+└───────────────────────────┬──────────────────────────────────┘
+                            │
+┌───────────────────────────▼──────────────────────────────────┐
+│  core/                                                        │
+│   task_state  Typed TaskState (objective, plan, decisions)    │
+│   memory     Typed memory registry by kind and scope         │
+│   refs       Content-addressed store (verified on read)      │
+│   prefix     Zones, 3-hash system, drift, PrefillPlan        │
+│   prune      Reversible externalization, 4 modes             │
+│   query      Server-side payload filtering (grep, range...)  │
+│   compaction trim / compact / clear (lossless)               │
+│   pressure   Context pressure metrics & tracking             │
+│   loopguard  Fingerprinting, 5 loop patterns detection       │
+│   invariants TOML rule engine (guard rails)                  │
+│   compass    Tool Compass (dynamic relevance scoring)        │
+│   handoff    Executable agent delegation contracts           │
+│   events     Append-only event journal + checkpoints         │
+│   ledger     Tokens / cost / savings / OSIRIS overhead       │
+│   fileops    Sandboxed file inspection (roots, size limits)  │
+│   redact     Secret scrubbing before any hashing             │
+│   policy     Budget policies & token enforcement             │
+└───────────────────────────┬──────────────────────────────────┘
+                            ▼
+        ~/.osiris/osiris.db  +  ~/.osiris/reports/
+```
+
+---
+
+## 5. Memory Model
+
+Deterministic, typed, content-addressable memory — **not** an opaque vector database.
+
+```
+TaskState
+├── objective      immutable
+├── constraints[]  append-only
+├── decisions[]    append-only, pinned verbatim
+├── plan           completed / active / remaining steps
+├── files{}        path, SHA-256 hash, mtime, last access, ref
+├── tool_results{} cache_key, ref, size, token cost, TTL
+├── failures{}     error signature, tool, args hash, attempts, lesson
+├── lessons[]      general behavioral rules learned
+├── handoffs{}     cross-agent delegation contracts
+└── budget         estimated vs consumed tokens and cost
+```
+
+Scopes: `task` → `project` → `agent` → `global`.
+
+---
+
+## 6. Cache-Aware Pruning
+
+**Security Invariant: Pruning moves payload data to content-addressed refs (`mem://sha256:…`). It NEVER deletes.**
+
+```
+ZONE_A_pruning_cost = pruned_tokens
+ZONE_C_or_D_pruning_cost = 0                      ← always zero cost
+net_savings = pruned_tokens − (prefix_tokens × P(cache_dead) × prefix_pruned)
+```
+
+| Mode | Trigger | Evicts | Cache Impact | Use Case |
+|---|---|---|---|---|
+| `cache_ttl` (default) | `Δt > TTL` | C/D, and A/B only if cache expired | Neutral | **Recommended default** |
+| `conservative` | Very high threshold | Working zone (C/D) only | Zero | High-cost API models |
+| `balanced` | Moderate threshold | C/D + cold historical turns | Zero | Standard agent workflows |
+| `aggressive` | Low threshold | Everything rehydratable | Minor prefill risk | Fast local LLMs |
+
+---
+
+## 7. LoopGuard Protection
+
+```
+fingerprint = sha256(tool ‖ canonical_args ‖ result_signature)
+```
+
+| Detection | Trigger Signal | Verdict |
+|---|---|---|
+| Exact duplicate | Identical fingerprint | `suggest_alternative` |
+| Repeated failure | Same error signature (≥3 times) | `block` + `required_action` |
+| Loop pattern | Same error across varying args | `warn` |
+| Oscillation | Alternating A/B/A/B pattern | `warn` |
+| Runaway | N calls with zero state progress | `warn` / `block` |
+
+---
+
+## 8. Invariants (Guard Rails)
+
+Define project safety rules in `.osiris/invariants.toml`:
+
+```toml
+[[invariant]]
+id = "tests-before-commit"
+when = { tool = "git.commit" }
+require = { state = "tests_passed" }
+message = "Cannot commit while tests are failing"
+
+[[invariant]]
+id = "no-test-edit"
+when = { path_glob = "tests/**" }
+verdict = "block"
+message = "Modifying test suites requires explicit approval"
+```
+
+---
+
+## 9. Lossless Verification & Non-Loss Proof
+
+OSIRIS guarantees full auditability for offloaded data:
+
+1. **Self-verifying refs**: `mem://sha256:<hash>`. Reads re-verify data integrity against the hash before returning.
+2. **Zero deletion paths**: data is relocated to the local store, never pruned permanently.
+3. **Reproducible audit**:
+   ```bash
+   python -m osiris audit --task <task_id>
+   ```
+   Outputs cryptographic proof of non-loss:
+   ```json
+   {"lossless": true, "items_externalized": 14, "items_verified": 14, "items_missing": 0, "integrity_violations": []}
+   ```
+
+---
+
+## 10. Verified Benchmarks
+
+Real measurements from `python bench\run_bench.py` running an automated coding workflow:
+
+| Payload Size | Baseline Context | Fixed OSIRIS | Adaptive OSIRIS | Net Improvement | OSIRIS Mode | Overhead |
+|---|---|---|---|---|---|---|
+| **200 tok** | 1,583 | 2,687 | **1,651** | **−4.30%** | bystander | 34 tok |
+| **800 tok** | 3,851 | 3,755 | **3,261** | **+15.32%** | light | 1,810 tok |
+| **2,000 tok** | 9,015 | 5,229 | **5,233** | **+41.95%** | standard | 2,492 tok |
+| **5,000 tok** | 20,979 | 8,171 | **8,168** | **+61.07%** | standard | 2,439 tok |
+| **20,000 tok** | 82,135 | 23,427 | **23,440** | **+71.46%** | full | 2,422 tok |
+
+- **Access Cost**: 1,019 tokens of schemas, amortized across session tasks.
+- **Session Net Gate**: PASS (Worst-case net across full suite: **+951 tokens**).
+- **At 20,000 tokens**: **+71.46% net savings** on context usage.
+
+---
+
+## 11. Quick Start
+
+```powershell
+cd D:\MCP-Osiris
+uv venv --python 3.12 .venv
+uv pip install --python .venv\Scripts\python.exe -e ".[dev]"
+```
+
+### CLI Verification
+
+```powershell
+.venv\Scripts\python.exe -m pytest tests -q        # Run test suite (76 passed)
+.venv\Scripts\python.exe -m ruff check src tests    # Code linting
+.venv\Scripts\python.exe -m osiris health           # Server health check
+.venv\Scripts\python.exe -m osiris audit --task t_1 # Cryptographic non-loss proof
+.venv\Scripts\python.exe bench\run_bench.py         # Reproduce benchmarks
+```
+
+### Registration as MCP Server
+
+Add to your client configuration (`mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "osiris": {
+      "command": "D:\\mcp-osiris\\.venv\\Scripts\\python.exe",
+      "args": ["-m", "osiris"],
+      "env": {
+        "OSIRIS_HOME": "C:\\Users\\Tech\\.osiris",
+        "OSIRIS_ROOTS": "D:\\mcp-osiris"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 12. Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install mcp-osiris          # or: uv pip install mcp-osiris
+mcp-osiris                      # runs the MCP server on stdio
+osiris health                   # CLI verification
+osiris-dashboard --port 8770    # Control Plane (dashboard)
+```
+
+### From npm (no Python setup)
+
+```bash
+npx -y osiris-mcp
+```
+
+The npm package is a stdio launcher. It resolves the Python runtime in this
+order — `OSIRIS_PYTHON` → `uvx` → `python3` → `python` — and runs the PyPI
+package `mcp-osiris`.
+
+### From source
+
+```powershell
+git clone https://github.com/MlkBlk-IT/osiris.git
+cd osiris
+uv venv --python 3.12 .venv
+uv pip install --python .venv\Scripts\python.exe -e ".[dev]"
+```
+
+### MCP client configuration
+
+```json
+{
+  "mcpServers": {
+    "osiris": {
+      "command": "npx",
+      "args": ["-y", "osiris-mcp"],
+      "env": {
+        "OSIRIS_HOME": "~/.osiris",
+        "OSIRIS_ROOTS": "/path/to/project"
+      }
+    }
+  }
+}
+```
+
+| Variable | Default | Role |
+|---|---|---|
+| `OSIRIS_HOME` | `~/.osiris` | SQLite database, reports, caches |
+| `OSIRIS_ROOTS` | *(empty)* | Roots allowed for file reading (`;` separated) |
+| `OSIRIS_CACHE_TTL_S` | `300` | Cache TTL (seconds) |
+| `OSIRIS_PRUNE_THRESHOLD_TOKENS` | `40000` | Prune threshold |
+| `OSIRIS_DISPATCH_ONLY` | `0` | `1` → exposes only `osiris.call` |
+
+---
+
+## License
+
+MIT © 2026 Malik Belkacemi (MLKBLK-IT)

mcp_osiris-0.1.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+osiris/__init__.py,sha256=hIkGDI346pRDo2xFmty6fGBjuNNBN1RmaG0zfc2Mqvw,233
+osiris/__main__.py,sha256=DQB4IBXvPaCYpyNyEGOlxp9ZJqalccb_7Zyuu_Qz9GU,646
+osiris/audit.py,sha256=D76vJzzKWx-5qOCSp_MAh_AVMNWksEjCQoN9RKfwztA,14572
+osiris/cli.py,sha256=hj2za2ce860sfVKO36tRdLANp_1bb3z9ibuhJU4Nzno,5489
+osiris/config.py,sha256=2O9OCagE5Yf8oNIjDuMMWAgZoYCdtyqI_tZAy_fIG68,5736
+osiris/server.py,sha256=wHdoUdaCi6loovqtqEu3TLWX0YgCSFiXyoon9rLDyHw,58479
+osiris/core/__init__.py,sha256=a5t5mx-n4ihQMc_JDeP8SG20B_2tztl_hP2p7oAYLaU,380
+osiris/core/adaptive.py,sha256=io1pS5ufdrJVCtHTuJghrK755jikyF2m5Cf6rDmOLtc,8849
+osiris/core/compaction.py,sha256=vs-Xywjmx0jC6Sp97Yh_AWX6FNuSmFqNAp4soKLQ3oI,4189
+osiris/core/compass.py,sha256=NIQ9TUEuR_LAqlSxVLKddbk60sgOzfqJeUYo7bibldY,4654
+osiris/core/db.py,sha256=X4s_Jd7FaV0H2NOFVYwYtoOPRUY0hZUR4pSTDmUvcjQ,6459
+osiris/core/errors.py,sha256=XN574I-fJMStAnKiKbRGIo0Khwa3nTSaFQ71vgROXm8,531
+osiris/core/events.py,sha256=uljEPcHFuWKXWg_1REmQuzE1gWq9VX1ZGcatBv6XnbE,8052
+osiris/core/fileops.py,sha256=MLdWLyRTEgcalwycBxdkdVfC-tSXpSVarNOSI3tCSOg,3009
+osiris/core/handoff.py,sha256=_6dTztUyMPe5X_zSgOUvVU1FmIDJlS1I4MIxPbXPr74,5514
+osiris/core/ids.py,sha256=qjFc2zlpb9ch5DNA9ZTBpsWBFHuCDKThHz0e9_Y5j4c,2775
+osiris/core/invariants.py,sha256=-1jW3o6WnoMfJhWLNm5Rhr6u_j5n6W4DDsbET5R1Vq4,6126
+osiris/core/ledger.py,sha256=HbBdLicZQLDW-KGJiqwfzkUMy4ZiGjmZsBoUO8CNegk,9564
+osiris/core/loopguard.py,sha256=abDzNCF7sTOi-YdLU_jdmE13kn5DBcWb6cLfu7wHdmo,9393
+osiris/core/manifest.py,sha256=JMuIDIZbCe_dZIivgapzhunemYkptKSqONiBDUA63G8,1981
+osiris/core/memory.py,sha256=5q0-FZXfUe9nKK1nRkd7Cy6gcCyV77VYK2-E2_Tbt9E,4405
+osiris/core/policy.py,sha256=RARguVv5oZeGHt3L9vfmx0Fj8M03-hbS79B4fbA0SHk,3225
+osiris/core/prefix.py,sha256=_LEQ_F96a2zQeBFL_L06gcqZYfDzaN3XNqIXdi60pbE,13091
+osiris/core/pressure.py,sha256=kMdNTjvthIyUs2pfmTx3kGDRfLSgsJet3Wm2-WL7s34,3801
+osiris/core/prune.py,sha256=bPLjlNMTuoibbplRpiesuM1SaVN1o82mIZEtdXbQIqs,7385
+osiris/core/query.py,sha256=ly673JLtd70J_nPSvLxwJqZqml1Kz2DTjt6BeezMrO4,8977
+osiris/core/redact.py,sha256=sltjnymqXUeLN_APVVyi3BvFq-FYQkJzn-tqyMor7hE,2580
+osiris/core/refs.py,sha256=ZssvuUJ5ut2jENXcMAgrTcUb866S12AltiuF8H5ej1Y,7864
+osiris/core/runtime.py,sha256=A1NH8PRVBruGGbtwIVC7_wFPE8KGXjohD4oIVFr5oog,5461
+osiris/core/task_state.py,sha256=MZzSWbsZUTsfEBXLiQf3I7Eg8bxTlF-jTIycf3hJPQ4,10855
+osiris/core/tokens.py,sha256=dCuMczIGT-RdTUPml19vcKEjFqrmrK9qQvCTpjL_tAs,1524
+osiris/tools/__init__.py,sha256=KnPx-9NuujnNcQ1reLiqCfP1T9HjfeDv912Z2N7l3hM,1303
+osiris/bench/__init__.py,sha256=cqjQfAyklkJy_Hp6J95rUXaCPO0r1pEScVoEi0FmSnI,139
+osiris/bench/run_bench.py,sha256=xJEbcEz2VHJYzsAPrFovhnxZNt7HKXV9xKXYjykJY4U,20902
+osiris/dashboard/__init__.py,sha256=lER6miniv9v5fFKLuVZ0GYLgSPcvjZ-YdCtk7CPTu3c,290
+osiris/dashboard/server.py,sha256=9zXfVJ3Rd4E15XoCc4ZPhFqw0xEYiP6DtNc3fxkJHMk,31666
+osiris/dashboard/web/app.js,sha256=ZB7ie9V5-jovCY9R4T_3AbcbLQ1esHo5AQPJHlbYbvo,44598
+osiris/dashboard/web/index.html,sha256=-wc23VqSMmZSYANMPtD2zL1CMNKK5LmiuFoWlGrUS2M,6442
+osiris/dashboard/web/logo.svg,sha256=_vptdDwlHMGZyrL4HVgFuLClZrqH6nRraLe8FMbWDrA,1234
+osiris/dashboard/web/styles.css,sha256=Qd2_WbR3H-P3qvXB7GnTPAB5aFxWrV9WFeVYK6iWJew,14989
+osiris/bench/fixtures/src/Profile.psm1,sha256=RVhYNPNQl-Y11ZVXAUdnefaabD-VoONl3vsOyf8MH60,8549
+osiris/bench/fixtures/tests/Profile.Tests.ps1,sha256=bnFGT4qxVC8UrEm2qeqmZ6GC-Ce1AINZp8S4hjR_Caw,1102
+mcp_osiris-0.1.0.dist-info/METADATA,sha256=Qzvd8QEJrS9SjigpXC9T7uE8jV-_OXj6PP0N8gOjewg,15939
+mcp_osiris-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+mcp_osiris-0.1.0.dist-info/entry_points.txt,sha256=nOaXY6qF8Q2ger80Nnt3P8wA6s816U5NUE4Mv5kdMco,123
+mcp_osiris-0.1.0.dist-info/licenses/LICENSE,sha256=wVul2ls1DM9HmmqTDHQmiuJx5wUC5H6LFhgJiU-WGZE,1084
+mcp_osiris-0.1.0.dist-info/RECORD,,

mcp_osiris-0.1.0.dist-info/WHEEL

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

mcp_osiris-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+mcp-osiris = osiris.server:main
+osiris = osiris.cli:main
+osiris-dashboard = osiris.dashboard.server:main

mcp_osiris-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Malik Belkacemi (MLKBLK-IT)
+
+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.

osiris/__init__.py

@@ -0,0 +1,9 @@
+"""OSIRIS — context engine cache-aware pour agents IA.
+
+Serveur MCP standard, local-first, independant de tout provider.
+"""
+
+from osiris.config import settings
+
+__version__ = settings.version
+__all__ = ["settings", "__version__"]

osiris/__main__.py

@@ -0,0 +1,28 @@
+"""Point d'entree : `python -m osiris` (serveur MCP) ou `python -m osiris <cmd>` (CLI)."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> int:
+    # Sans argument : serveur MCP en stdio.
+    # Avec un argument : CLI locale (health, tasks, audit, report, bench).
+    if len(sys.argv) > 1 and sys.argv[1] in {
+        "health",
+        "tasks",
+        "audit",
+        "report",
+        "bench",
+    }:
+        from osiris.cli import main as cli_main
+
+        return cli_main(sys.argv[1:])
+    from osiris.server import main as server_main
+
+    server_main()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())