icycache 0.3.2__py3-none-any.whl

icycache/__init__.py

@@ -0,0 +1,32 @@
+"""IcyCache — passerelle LLM universelle avec cache local.
+
+Le code vit dans `icycache/src/`, avec `config/` et `static/` a cote — exactement
+la disposition du depot (`src/`, `config/`, `static/`). Comme dans le depot, les
+modules s'importent a plat (`import server`, `import icy_core`, ...) : on ajoute
+donc `src/` au `sys.path` pour que les imports fonctionnent a l'identique dans
+les deux modes (checkout source et installation pip).
+
+`PROJECT_ROOT` est le repertoire qui contient `config/` et `static/` :
+- mode depot    -> la racine du repo
+- mode installe -> le paquet lui-meme (site-packages/icycache)
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+__version__ = "0.2.0"
+
+_HERE = Path(__file__).resolve().parent
+
+_SRC = _HERE / "src"
+if _SRC.is_dir() and str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+
+# La racine qui porte config/ et static/.
+if (_HERE / "config").is_dir():
+    PROJECT_ROOT = _HERE
+else:
+    PROJECT_ROOT = _HERE.parent
+
+__all__ = ["__version__", "PROJECT_ROOT"]

icycache/__main__.py

@@ -0,0 +1,9 @@
+"""Permet `python -m icycache ...` en plus du script console `icycache`."""
+from __future__ import annotations
+
+import sys
+
+from icycache.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

icycache/cli.py

@@ -0,0 +1,171 @@
+"""CLI IcyCache.
+
+    icycache serve            # la gateway HTTP (port 8080)
+    icycache mcp              # la couche MCP (SSE 8081 / HTTP 8084 / stdio)
+    icycache doctor           # diagnostic : chemins, config, upstreams, base
+    icycache paths            # ou sont stockees les donnees
+    icycache version
+
+`serve` et `mcp` relancent les vrais scripts (`src/server.py`, `src/mcp_server.py`)
+dans un sous-processus : la CLI n'ecrit aucune logique de demarrage, elle ne fait
+que choisir le point d'entree et transmettre les arguments.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from . import PROJECT_ROOT, __version__
+
+_SRC = PROJECT_ROOT / "src"
+
+
+def _run(script: str, extra: list[str]) -> int:
+    target = _SRC / script
+    if not target.exists():
+        print(f"[icycache] introuvable: {target}", file=sys.stderr)
+        return 2
+    cmd = [sys.executable, str(target), *extra]
+    print(f"[icycache] {' '.join(cmd)}", file=sys.stderr)
+    return subprocess.call(cmd)
+
+
+def _cmd_serve(args) -> int:
+    extra: list[str] = []
+    if args.host:
+        extra += ["--host", args.host]
+    if args.port:
+        extra += ["--port", str(args.port)]
+    return _run("server.py", extra)
+
+
+def _cmd_mcp(args) -> int:
+    # stdio passe par une entree dediee : l'import de mcp_server.py ecrit sur
+    # stdout, qui appartient au JSON-RPC sur ce transport.
+    if args.mode == "mcp-stdio":
+        return _run("mcp_stdio_entry.py", [])
+    return _run("mcp_server.py", ["--mode", args.mode])
+
+
+def _cmd_paths(args) -> int:
+    sys.path.insert(0, str(_SRC))
+    from icy_paths import DATA_DIR, IS_SOURCE_CHECKOUT, PROJECT_ROOT as ROOT
+
+    print(f"mode            : {'depot (source)' if IS_SOURCE_CHECKOUT else 'installe (pip)'}")
+    print(f"PROJECT_ROOT    : {ROOT}")
+    print(f"DATA_DIR        : {DATA_DIR}")
+    print(f"config gateway  : {ROOT / 'config' / 'icycache.gateway.json'}")
+    print(f"config legacy   : {ROOT / 'config' / 'icycache.json'}")
+    print(f"base (cache.db) : {DATA_DIR / 'db' / 'cache.db'}")
+    print(f"logs            : {DATA_DIR / 'logs'}")
+    print(f"static          : {ROOT / 'static'}")
+    return 0
+
+
+def _cmd_doctor(args) -> int:
+    sys.path.insert(0, str(_SRC))
+    import icy_paths
+
+    problems: list[str] = []
+
+    print("== IcyCache ==")
+    print(f"version         : {__version__}")
+    print(f"python          : {sys.executable}")
+    print(f"PROJECT_ROOT    : {icy_paths.PROJECT_ROOT}")
+    print(f"DATA_DIR        : {icy_paths.DATA_DIR}")
+    print(f"mode            : {'depot (source)' if icy_paths.IS_SOURCE_CHECKOUT else 'installe (pip)'}")
+
+    cfg_path = Path(os.environ.get("ICYCACHE_CONFIG") or (icy_paths.PROJECT_ROOT / "config" / "icycache.gateway.json"))
+    print(f"\n== config ==\n{cfg_path}")
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+        except Exception as exc:  # noqa: BLE001
+            problems.append(f"config illisible: {exc}")
+            cfg = {}
+        ups = sorted(cfg.get("upstreams", {}))
+        gw = cfg.get("gateway", {})
+        print(f"upstreams       : {len(ups)} -> {', '.join(ups)}")
+        print(f"default         : {gw.get('default_upstream') or '(aucun - explicite obligatoire)'}")
+        print(f"sticky_upstream : {gw.get('sticky_upstream')}")
+        cache = cfg.get("cache", {})
+        print(f"cache           : max_entries={cache.get('max_entries')} "
+              f"semantic={cache.get('enable_semantic')} ttl={cache.get('ttl_seconds')}")
+        db = icy_paths.resolve_data_path(cache.get("db_path"), "db/cache.db")
+    else:
+        problems.append(f"config absent: {cfg_path}")
+        db = icy_paths.DATA_DIR / "db" / "cache.db"
+
+    print(f"\n== base ==\n{db}")
+    print(f"existe          : {db.exists()}"
+          + (f" ({db.stat().st_size} octets)" if db.exists() else ""))
+    parent = db.parent
+    if not parent.exists():
+        problems.append(f"repertoire de base absent (sera cree au demarrage): {parent}")
+    elif not os.access(parent, os.W_OK):
+        problems.append(f"repertoire de base non inscriptible: {parent}")
+
+    static = icy_paths.PROJECT_ROOT / "static" / "dashboard.html"
+    print(f"\n== dashboard ==\n{static}\nexiste          : {static.exists()}")
+    if not static.exists():
+        problems.append(f"dashboard absent: {static}")
+
+    print()
+    if problems:
+        print("== PROBLEMES ==")
+        for p in problems:
+            print(f"  - {p}")
+        return 1
+    print("== OK ==")
+    return 0
+
+
+def _cmd_version(args) -> int:
+    print(__version__)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="icycache",
+        description="IcyCache — passerelle LLM universelle avec cache local.",
+    )
+    sub = parser.add_subparsers(dest="cmd")
+
+    p = sub.add_parser("serve", help="Demarrer la gateway HTTP (defaut 127.0.0.1:8080).")
+    p.add_argument("--host", default=None)
+    p.add_argument("--port", type=int, default=None)
+    p.set_defaults(func=_cmd_serve)
+
+    p = sub.add_parser("mcp", help="Demarrer la couche MCP.")
+    p.add_argument("--mode", default="mcp-sse",
+                   choices=["proxy", "mcp-stdio", "mcp-sse", "mcp-http", "all"])
+    p.set_defaults(func=_cmd_mcp)
+
+    p = sub.add_parser("doctor", help="Diagnostic de l'installation.")
+    p.set_defaults(func=_cmd_doctor)
+
+    p = sub.add_parser("paths", help="Afficher ou sont stockees les donnees.")
+    p.set_defaults(func=_cmd_paths)
+
+    p = sub.add_parser("version", help="Afficher la version.")
+    p.set_defaults(func=_cmd_version)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

icycache/config/icycache.gateway.json

@@ -0,0 +1,111 @@
+{
+  "proxy": {
+    "host": "127.0.0.1",
+    "port": 8080,
+    "timeout": 120
+  },
+  "mcp": {
+    "host": "127.0.0.1",
+    "port": 8081,
+    "transport": ["stdio", "sse"]
+  },
+  "mcp_gateway": {
+    "host": "127.0.0.1",
+    "port": 8083,
+    "transport": ["stdio", "sse"],
+    "_note": "Serveur MCP de la gateway. 8081 est servi par mcp_server.py (serveur MCP)."
+  },
+  "gateway": {
+    "host": "127.0.0.1",
+    "port": 8082,
+    "default_upstream": "omniroute",
+    "ws_delta_interval_s": 0.25,
+    "sticky_upstream": true,
+    "_note": "default_upstream = defaut EXPLICITE de la config (pas de fallback code vers OmniRoute). null = le client doit nommer son upstream (prefixe /<upstream>/v1/..., header X-IcyCache-Upstream ou champ 'upstream')."
+  },
+  "upstreams": {
+    "omniroute": {"base_url": "http://localhost:20128", "kind": "openai"},
+    "lmstudio":  {"base_url": "http://localhost:1234",  "kind": "openai"},
+    "ollama":    {"base_url": "http://localhost:11434", "kind": "openai"},
+    "openai":    {"base_url": "https://api.openai.com", "kind": "openai"},
+    "anthropic": {"base_url": "https://api.anthropic.com", "kind": "anthropic"},
+    "nvidia":    {"base_url": "https://integrate.api.nvidia.com/v1", "kind": "openai"},
+    "groq":      {"base_url": "https://api.groq.com/openai/v1", "kind": "openai"},
+    "cerebras":  {"base_url": "https://api.cerebras.ai/v1", "kind": "openai", "headers": {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) HermesAgent/0.22.2"}},
+    "openrouter": {"base_url": "https://openrouter.ai/api/v1", "kind": "openai"},
+    "kilo":      {"base_url": "https://ai-gateway.kilo.ai/api/v1", "kind": "openai"},
+    "nous":      {"base_url": "https://inference-api.nousresearch.com/v1", "kind": "openai"},
+    "copilot":   {"base_url": "https://api.githubcopilot.com", "kind": "openai"},
+    "ai-gateway": {"base_url": "https://ai-gateway.vercel.sh/v1", "kind": "openai"},
+    "huggingface": {"base_url": "https://router.huggingface.co/v1", "kind": "openai"},
+    "google-aistudio": {"base_url": "https://generativelanguage.googleapis.com/v1beta/openai", "kind": "openai", "strip_v1": true},
+    "llm7io":    {"base_url": "https://api.llm7.io/v1", "kind": "openai"},
+    "mistral":   {"base_url": "https://api.mistral.ai/v1", "kind": "openai"},
+    "cloudflare": {"base_url": "https://api.cloudflare.com/client/v4/accounts/dfbe889cfe78700a4d10897cfd3b581d/ai/v1", "kind": "openai", "headers": {"cf-aig-gateway-id": "default"}}
+  },
+  "cache": {
+    "db_path": "db/cache.db",
+    "max_entries": 50000,
+    "enable_semantic": false,
+    "semantic_threshold": 0.95,
+    "ttl_seconds": 604800,
+    "cache_when_temperature_unset": true,
+    "embeddings_ttl_seconds": 604800
+  },
+  "loop_guard": {
+    "enabled": true,
+    "window_seconds": 300,
+    "tools": {"warn_after": 3, "block_after": 5, "max_cycle_len": 3},
+    "llm": {"warn_after": 3, "action": "warn", "block_after": 6}
+  },
+  "tool_cache": {
+    "enabled": true,
+    "default": "allow",
+    "max_result_bytes": 10485760,
+    "downstream": {
+      "github": {"transport": "stdio", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"]},
+      "fetch": {"transport": "stdio", "command": "uvx", "args": ["mcp-server-fetch@2026.10.10"]},
+      "omniroute": {"transport": "sse", "url": "http://127.0.0.1:20128/mcp"},
+      "qwen-chroma": {"transport": "stdio", "command": "python", "args": ["C:/AI/EmbeddingDB/hermes_qdrant_mcp.py"]},
+      "icycache": {"transport": "sse", "url": "http://127.0.0.1:8081/sse"},
+      "loom": {"transport": "stdio", "command": "D:/Loom/.venv/Scripts/loom-mcp.exe"},
+      "wispr_flow_mcp": {"transport": "stdio", "command": "wispr-flow-mcp"},
+      "dak-notebook": {"transport": "stdio", "command": "dak-notebook"},
+      "dak-viz": {"transport": "stdio", "command": "dak-viz"},
+      "dak-bigquery": {"transport": "stdio", "command": "dak-bigquery"},
+      "dak-gcs": {"transport": "stdio", "command": "dak-gcs"},
+      "dak-spanner": {"transport": "stdio", "command": "dak-spanner"}
+    },
+    "policy": {
+      "github.*": {"ttl_seconds": 3600},
+      "fetch.*": {"ttl_seconds": 3600},
+      "omniroute.*": {"ttl_seconds": 1800},
+      "qwen-chroma.*": {"ttl_seconds": 7200},
+      "icycache.*": {"ttl_seconds": 300},
+      "loom.*": {"ttl_seconds": 3600},
+      "wispr_flow_mcp.*": {"ttl_seconds": 600},
+      "dak-.*": {"ttl_seconds": 1800}
+    },
+    "_example": {
+      "downstream": {"srv1": {"transport": "stdio", "command": "node", "args": ["server.js"]}},
+      "policy": {"srv1.nom_du_tool": {"ttl_seconds": 60}}
+    }
+  },
+  "normalization": {
+    "remove_politeness": true,
+    "canonical_synonyms": {
+      "config": "configuration",
+      "setup": "configuration",
+      "stp": "",
+      "s'il te pla\u00eet": "",
+      "please": "",
+      "can you": "",
+      "peux-tu": ""
+    }
+  },
+  "logging": {
+    "level": "INFO",
+    "file": "logs/app.log",
+    "max_size_mb": 10
+  }
+}

icycache/config/icycache.json

@@ -0,0 +1,149 @@
+{
+  "proxy": {
+    "host": "127.0.0.1",
+    "port": 8080,
+    "target_provider": "http://localhost:20128/v1/chat/completions",
+    "api_key": null,
+    "timeout": 120
+  },
+  "mcp": {
+    "host": "127.0.0.1",
+    "port": 8081,
+    "transport": [
+      "stdio",
+      "sse"
+    ],
+    "_note": "8081 = transport SSE (clients legacy / Hermes). Le transport moderne streamable-http ecoute sur mcp_http.port."
+  },
+  "mcp_http": {
+    "host": "127.0.0.1",
+    "port": 8084,
+    "_note": "Streamable HTTP (transport standard des clients MCP recents). Endpoint: http://127.0.0.1:8084/mcp"
+  },
+  "cache": {
+      "db_path": "db/cache.db",
+      "max_entries": 200000,
+      "enable_semantic": true,
+      "semantic_threshold": 0.80,
+      "ttl_seconds": 2592000
+    },
+    "tool_cache": {
+      "enabled": true,
+      "ttl_seconds": 3600,
+      "window_seconds": 1800,
+      "tools": {
+        "warn_after": 3,
+        "block_after": 5,
+        "max_cycle_len": 3
+      }
+    },
+    "tool_proxy": {
+      "list_cache_seconds": 30,
+      "_note": "Jetons de portabilite: {PROJECT_ROOT} = racine du projet, {PYTHON} = interpreteur du venv. Le cache d'outils est OPT-IN; 'cache_tools' = allowlist stricte; sinon 'cache: true' active la detection anti-ecriture (create_/write_/delete_/push_... jamais caches).",
+      "servers": {
+        "fetch": {
+          "command": "uvx",
+          "args": ["mcp-server-fetch@2026.10.10"],
+          "cache": true
+        },
+        "github": {
+          "command": "npx",
+          "args": ["-y", "@modelcontextprotocol/server-github"],
+          "env": {
+            "GITHUB_PERSONAL_ACCESS_TOKEN": "@hermes:mcp_servers.github"
+          },
+          "cache": true,
+          "cache_tools": {
+            "_note": "Allowlist stricte des outils de LECTURE reels de @modelcontextprotocol/server-github (26 outils au total). Les 12 outils d'ecriture (create_*, push_files, fork_repository, merge_*, update_*) ne sont JAMAIS mis en cache: sinon l'ecriture est sautee silencieusement.",
+            "search_issues": true,
+            "search_code": true,
+            "search_repositories": true,
+            "search_users": true,
+            "get_issue": true,
+            "get_pull_request": true,
+            "get_pull_request_files": true,
+            "get_pull_request_status": true,
+            "get_pull_request_comments": true,
+            "get_pull_request_reviews": true,
+            "get_file_contents": true,
+            "list_issues": true,
+            "list_pull_requests": true,
+            "list_commits": true
+          }
+        },
+        "qwen-chroma": {
+          "command": "C:\\AI\\EmbeddingDB\\.venv\\Scripts\\python.exe",
+          "args": ["C:\\AI\\EmbeddingDB\\hermes_qdrant_mcp.py"],
+          "cache": true,
+          "ttl_seconds": 259200,
+          "_note": "cache: true + detection anti-ecriture: memory_search_tool / hybrid_search_tool / memory_stats_tool sont caches; memory_add_tool / memory_delete_tool / rebuild_bm25_index_tool sont executes a chaque appel."
+        },
+        "pwsh": {
+          "command": "uvx",
+          "args": ["pwsh-exec@1.0.1"],
+          "cache": false
+        },
+        "filesystem": {
+          "command": "npx",
+          "args": ["-y", "@modelcontextprotocol/server-filesystem", "D:\\\\", "C:\\\\Users\\\\Tech\\\\AppData\\\\Local\\\\hermes"],
+          "cache": false
+        },
+        "websearch": {
+          "command": "uvx",
+          "args": ["mcp-server-brave-search@2026.10.10"],
+          "env": {
+            "BRAVE_API_KEY": "@hermes:mcp_servers.brave"
+          },
+          "cache": true
+        },
+        "sqlite": {
+          "command": "uvx",
+          "args": ["mcp-server-sqlite@2025.4.25", "--db-path", "D:\\IcyCache\\db\\cache.db"],
+          "cache": true
+        },
+        "docker": {
+          "command": "uvx",
+          "args": ["mcp-server-docker@0.3.0"],
+          "cache": false
+        },
+        "postgres": {
+          "command": "uvx",
+          "args": ["mcp-server-postgres@0.1.0"],
+          "env": {
+            "POSTGRES_CONNECTION_STRING": "@hermes:mcp_servers.postgres"
+          },
+          "cache": false
+        },
+        "redis": {
+          "command": "uvx",
+          "args": ["mcp-server-redis@0.1.1"],
+          "env": {
+            "REDIS_URL": "@hermes:mcp_servers.redis"
+          },
+          "cache": true
+        },
+        "kubernetes": {
+          "command": "uvx",
+          "args": ["mcp-server-kubernetes@0.1.6"],
+          "cache": false
+        }
+      }
+    },
+    "normalization": {
+    "remove_politeness": true,
+    "canonical_synonyms": {
+      "config": "configuration",
+      "setup": "configuration",
+      "stp": "",
+      "s'il te pla\u00eet": "",
+      "please": "",
+      "can you": "",
+      "peux-tu": ""
+    }
+  },
+  "logging": {
+    "level": "INFO",
+    "file": "logs/app.log",
+    "max_size_mb": 10
+  }
+}