add mini-context-graph skill (#1580)

* add mini-context-graph skill * remove pycache files * filename case update to SKILL.md * update readme
2026-05-05 14:42:12 +00:00 · 2026-05-05 09:34:37 +05:30
parent 1f96bce626
commit 746ba555b6
16 changed files with 2343 additions and 0 deletions
@@ -0,0 +1,175 @@
+"""
+ontology_store.py — Tracks entity types and relation types.
+
+Handles:
+- Registering types and relations with usage counts
+- Normalizing types and relations via synonym mapping
+- Persisting to ontology.json
+
+NOTE: No LLM logic here. Normalization is rule-based (lowercase + synonym map).
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+import config
+
+_DATA_DIR = Path(os.environ.get("MINI_CONTEXT_GRAPH_DATA_DIR", str(config.DATA_DIR)))
+_ONTOLOGY_FILE = _DATA_DIR / "ontology.json"
+
+# Synonym maps — lowercase variants map to canonical forms
+_ENTITY_TYPE_MAP: dict[str, str] = {
+    "component": "component",
+    "module": "component",
+    "class": "component",
+    "function": "component",
+    "method": "component",
+    "bug": "issue",
+    "defect": "issue",
+    "fault": "issue",
+    "error": "issue",
+    "failure": "issue",
+    "problem": "issue",
+    "crash": "issue",
+    "server": "infrastructure",
+    "host": "infrastructure",
+    "machine": "infrastructure",
+    "node": "infrastructure",
+    "user": "actor",
+    "person": "actor",
+    "operator": "actor",
+    "admin": "actor",
+    "administrator": "actor",
+    "actor": "actor",
+    "app": "software",
+    "application": "software",
+    "service": "software",
+    "program": "software",
+    "software": "software",
+    "database": "storage",
+    "datastore": "storage",
+    "db": "storage",
+    "storage": "storage",
+    "api": "interface",
+    "endpoint": "interface",
+    "interface": "interface",
+    "connection": "interface",
+    "event": "event",
+    "incident": "event",
+    "occurrence": "event",
+    "trigger": "event",
+    "concept": "concept",
+    "idea": "concept",
+    "principle": "concept",
+    "theory": "concept",
+    "process": "process",
+    "thread": "process",
+    "task": "process",
+    "job": "process",
+    "workflow": "process",
+    "object": "component",
+    "resource": "component",
+    "memory": "resource",
+    "cpu": "resource",
+    "system": "system",
+    "platform": "system",
+    "framework": "system",
+    "library": "software",
+    "package": "software",
+}
+
+_RELATION_TYPE_MAP: dict[str, str] = {
+    "causes": "causes",
+    "triggers": "causes",
+    "leads to": "causes",
+    "results in": "causes",
+    "produces": "causes",
+    "is part of": "contains",
+    "belongs to": "contains",
+    "lives in": "contains",
+    "sits in": "contains",
+    "contains": "contains",
+    "depends on": "depends on",
+    "requires": "depends on",
+    "needs": "depends on",
+    "uses": "uses",
+    "calls": "uses",
+    "invokes": "uses",
+    "consumes": "uses",
+    "affects": "affects",
+    "impacts": "affects",
+    "influences": "affects",
+    "creates": "creates",
+    "instantiates": "creates",
+    "spawns": "creates",
+    "connects to": "connects to",
+    "links to": "connects to",
+    "references": "connects to",
+    "inherits from": "extends",
+    "extends": "extends",
+    "subclasses": "extends",
+    "reads from": "reads from",
+    "queries": "reads from",
+    "fetches": "reads from",
+    "writes to": "writes to",
+    "stores in": "writes to",
+    "persists to": "writes to",
+    "contributes to": "contributes to",
+    "allocated by": "allocated by",
+    "released by": "released by",
+    "not released": "not released",
+}
+
+
+def _load() -> dict:
+    if _ONTOLOGY_FILE.exists():
+        with open(_ONTOLOGY_FILE, "r") as f:
+            return json.load(f)
+    return {"entity_types": {}, "relation_types": {}}
+
+
+def _save(ontology: dict) -> None:
+    _DATA_DIR.mkdir(parents=True, exist_ok=True)
+    with open(_ONTOLOGY_FILE, "w") as f:
+        json.dump(ontology, f, indent=2)
+
+
+def normalize_type(type_name: str) -> str:
+    """Return the canonical form of an entity type."""
+    key = type_name.strip().lower().replace("-", " ").replace("_", " ")
+    return _ENTITY_TYPE_MAP.get(key, key)
+
+
+def normalize_relation(relation_name: str) -> str:
+    """Return the canonical form of a relation type."""
+    key = relation_name.strip().lower().replace("-", " ").replace("_", " ")
+    return _RELATION_TYPE_MAP.get(key, key)
+
+
+def add_type(type_name: str) -> None:
+    """Register an entity type, incrementing its usage count."""
+    ontology = _load()
+    canonical = normalize_type(type_name)
+    ontology["entity_types"][canonical] = ontology["entity_types"].get(canonical, 0) + 1
+    _save(ontology)
+
+
+def add_relation(relation_name: str) -> None:
+    """Register a relation type, incrementing its usage count."""
+    ontology = _load()
+    canonical = normalize_relation(relation_name)
+    ontology["relation_types"][canonical] = ontology["relation_types"].get(canonical, 0) + 1
+    _save(ontology)
+
+
+def get_all_types() -> dict[str, int]:
+    """Return all registered entity types with counts."""
+    return _load()["entity_types"]
+
+
+def get_all_relations() -> dict[str, int]:
+    """Return all registered relation types with counts."""
+    return _load()["relation_types"]