File size: 3,851 Bytes
f3072b7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """
MetaRulesEngine — Vitalis FSI
Rules are not hardcoded. They are HDC vectors.
Rules that correlate with success get reinforced.
Rules that correlate with failure get mutated or dropped.
New rules crystallize from repeated successful action sequences.
This is the system rewriting its own decision logic.
"""
import numpy as np
import os
import json
from vitalis_ide.math_core.kernel import VitalisKernel
class MetaRulesEngine:
REINFORCEMENT_RATE = 0.1
MUTATION_RATE = 0.05
PRUNE_THRESHOLD = 0.2
MAX_RULES = 50
def __init__(self):
self.kernel = VitalisKernel()
self.path = os.path.expanduser("~/.vitalis_workspace/meta_rules.json")
self.vec_path = os.path.expanduser("~/.vitalis_workspace/rule_vectors.npy")
self._load()
def _load(self):
self.rules = {}
self.rule_vectors = {}
if os.path.exists(self.path):
with open(self.path) as f:
self.rules = json.load(f)
if os.path.exists(self.vec_path):
self.rule_vectors = np.load(self.vec_path, allow_pickle=True).item()
def _save(self):
os.makedirs(os.path.dirname(self.path), exist_ok=True)
with open(self.path, 'w') as f:
json.dump(self.rules, f, indent=2)
np.save(self.vec_path, self.rule_vectors)
def crystallize(self, action_sequence: list, outcome: str):
"""
Repeated successful action sequences crystallize into rules.
The sequence becomes a rule the system applies automatically.
"""
key = "→".join(action_sequence)
vec = self.kernel.vectorize_tokens(action_sequence, positional=True)
if key not in self.rules:
self.rules[key] = {
"sequence": action_sequence,
"outcome": outcome,
"confidence": 0.5,
"uses": 0
}
self.rule_vectors[key] = vec
print(f"[META-RULES] Rule crystallized: {key}")
else:
r = self.rules[key]
if outcome == "success":
r["confidence"] = min(r["confidence"] + self.REINFORCEMENT_RATE, 1.0)
else:
r["confidence"] = max(r["confidence"] - self.REINFORCEMENT_RATE, 0.0)
r["uses"] += 1
self._save()
self._prune()
def _prune(self):
"""Drop rules below confidence threshold."""
to_drop = [k for k, v in self.rules.items()
if v["confidence"] < self.PRUNE_THRESHOLD and v["uses"] > 3]
for k in to_drop:
del self.rules[k]
self.rule_vectors.pop(k, None)
print(f"[META-RULES] Rule pruned: {k}")
if to_drop:
self._save()
def match(self, context: str) -> dict:
"""Find the highest-confidence rule for this context."""
ctx_vec = self.kernel.vectorize_tokens(context.split(), positional=False)
best_match = None
best_score = 0.0
for key, vec in self.rule_vectors.items():
sim = self.kernel.similarity(ctx_vec, vec)
confidence = self.rules[key]["confidence"]
score = sim * confidence
if score > best_score:
best_score = score
best_match = self.rules[key]
return {"rule": best_match, "score": round(best_score, 4)} if best_match else {}
def report(self) -> dict:
if not self.rules:
return {"status": "No rules crystallized yet"}
top = sorted(self.rules.items(), key=lambda x: x[1]["confidence"], reverse=True)[:5]
return {
"total_rules": len(self.rules),
"top_rules": [{"sequence": v["sequence"],
"confidence": round(v["confidence"], 3),
"uses": v["uses"]} for _, v in top]
}
|