File size: 14,568 Bytes
3757df8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
#!/usr/bin/env python3
"""Norovox Nythos — Self-Learning + Skill-Forge Runtime.

İki ayrı yetenek:

1. **SelfLearner**: Kullanıcı düzeltmelerini KB'ye ekler.
   Her konuşmadan sonra "ne öğrendi?" diye sentezler + bilgi tabanına yazar.
   Sonraki konuşmalarda otomatik hatırlar.

2. **SkillForge**: Kullanıcının öğrettiği yeni beceriyi kalıcı hale getirir.
   Örnek: "şöyle yaparsan: 1. X, 2. Y, 3. Z" dediğinde, runtime bunu
   bir "skill template" olarak kaydeder ve sonra benzer görevlerde
   otomatik uygular.

KULLANIM:
    from nythos_self_learning import SelfLearningChat

    chat = SelfLearningChat(
        model_url="http://localhost:8080/v1/chat/completions",
        kb_path="./norovox_kb.json",
        skills_path="./norovox_skills.json"
    )

    # Kullanıcı bir şey öğretir
    chat.sor("Şöyle yazıyorum: 'bilgi al(X)' demek 'X hakkında web arası yap + Türkçe özetle'")
    # → SkillForge bunu skill olarak kaydeder

    # Sonra aynı pattern'i kullanır
    chat.sor("bilgi al(Tesla)")
    # → otomatik web_ara + özetleme uygular
"""
import json, re, hashlib
from pathlib import Path
from datetime import datetime
from typing import Optional


# ════════════════════════════════════════════════════════════════
# KNOWLEDGE BASE — sürekli güncellenen bilgi tabanı
# ════════════════════════════════════════════════════════════════

class KnowledgeBase:
    """Basit JSON-tabanlı KB. Konu → fact mapping."""

    def __init__(self, path: str = "./norovox_kb.json"):
        self.path = Path(path)
        self.data: dict = {"facts": {}, "meta": {"created": str(datetime.now())}}
        if self.path.exists():
            try:
                self.data = json.loads(self.path.read_text(encoding="utf-8"))
            except Exception:
                pass

    def add(self, topic: str, fact: str, source: str = "user"):
        topic_key = topic.lower().strip()
        if topic_key not in self.data["facts"]:
            self.data["facts"][topic_key] = []
        self.data["facts"][topic_key].append({
            "fact": fact,
            "source": source,
            "added": str(datetime.now()),
        })
        self._save()

    def search(self, query: str, limit: int = 5) -> list:
        q = query.lower()
        matches = []
        for topic, facts in self.data["facts"].items():
            if any(w in topic for w in q.split()):
                matches.extend([f["fact"] for f in facts[:limit]])
        return matches[:limit]

    def remove(self, topic: str):
        self.data["facts"].pop(topic.lower(), None)
        self._save()

    def _save(self):
        self.path.write_text(json.dumps(self.data, ensure_ascii=False, indent=2),
                              encoding="utf-8")

    def size(self) -> int:
        return sum(len(v) for v in self.data["facts"].values())


# ════════════════════════════════════════════════════════════════
# SKILL FORGE — yeni beceri kazanma
# ════════════════════════════════════════════════════════════════

class SkillForge:
    """Kullanıcının öğrettiği yeni pattern/skill'leri kalıcı yapar.

    Skill = pattern + adımlar + örnek input/output
    Storage: JSON
    Eşleştirme: regex pattern üzerinden
    """

    SKILL_TEACHING_PATTERN = re.compile(
        r"(?:şöyle|şu şekilde|şunu yap|yaparsan)[:\s]+(.+)",
        re.IGNORECASE | re.DOTALL
    )

    def __init__(self, path: str = "./norovox_skills.json"):
        self.path = Path(path)
        self.skills: dict = {}
        if self.path.exists():
            try:
                self.skills = json.loads(self.path.read_text(encoding="utf-8"))
            except Exception:
                pass

    def _hash(self, name: str) -> str:
        return hashlib.sha256(name.encode()).hexdigest()[:8]

    def detect_teaching(self, user_input: str) -> Optional[dict]:
        """Kullanıcı bir şey öğretiyor mu tespit et."""
        # Pattern 1: "X komutu Y anlamına gelir"
        m1 = re.search(r"['\"]?(\w+\([^)]+\))['\"]?\s*(?:komutu|fonksiyonu|demek|anlamına geliyor)\s*['\"]?(.+?)['\"]?\s*$",
                        user_input, re.DOTALL)
        if m1:
            return {"name": m1.group(1), "definition": m1.group(2).strip()}

        # Pattern 2: "şöyle yap: ...adımlar..."
        m2 = self.SKILL_TEACHING_PATTERN.search(user_input)
        if m2:
            steps_text = m2.group(1).strip()
            # Numbered list?
            steps = re.findall(r"(?:^|[\n,])\s*\d+[.)]\s*([^\n,]+)", steps_text)
            if steps:
                first_line = user_input.split(":")[0].strip()
                return {"name": first_line[-40:], "steps": steps}

        # Pattern 3: "X yapmak için Y kullan"
        m3 = re.search(r"(\w+)\s+(?:yapmak için|için)\s+(.+)", user_input, re.IGNORECASE)
        if m3 and "kullan" in m3.group(2).lower():
            return {"name": m3.group(1), "method": m3.group(2)}

        return None

    def forge(self, skill_info: dict):
        """Yeni skill kaydet."""
        name = skill_info.get("name", "untitled")[:50]
        skill_id = self._hash(name)
        self.skills[skill_id] = {
            "name": name,
            "info": skill_info,
            "created": str(datetime.now()),
            "use_count": 0,
        }
        self._save()
        return skill_id

    def match(self, user_input: str) -> Optional[dict]:
        """Mevcut bir skill'in input'la eşleşip eşleşmediği."""
        for sid, skill in self.skills.items():
            name = skill["name"].lower()
            # Pattern: skill name + arg pattern
            base_name = re.sub(r"\([^)]*\)", "", name).strip()
            if base_name and base_name in user_input.lower():
                skill["use_count"] += 1
                self._save()
                return skill
        return None

    def list_skills(self) -> list:
        return [(s["name"], s["use_count"]) for s in self.skills.values()]

    def _save(self):
        self.path.write_text(json.dumps(self.skills, ensure_ascii=False, indent=2),
                              encoding="utf-8")


# ════════════════════════════════════════════════════════════════
# SELF-LEARNER — konuşmadan sonuç çıkartma
# ════════════════════════════════════════════════════════════════

class SelfLearner:
    """Konuşmayı analiz eder, KB'ye eklenebilecek fact'leri çıkartır."""

    FACT_PATTERNS = [
        (re.compile(r"(\w[\w\s]+?)\s+(?:şudur|şöyledir|şuna eşittir|=)\s+(.+?)(?:\.|$)", re.I),
         lambda m: (m.group(1).strip(), m.group(2).strip())),
        (re.compile(r"benim adım\s+(.+?)(?:\.|$)", re.I),
         lambda m: ("kullanıcı adı", m.group(1).strip())),
        (re.compile(r"(?:tercih ediyorum|seviyorum):\s*(.+?)(?:\.|$)", re.I),
         lambda m: ("kullanıcı tercihi", m.group(1).strip())),
        (re.compile(r"(\w+)\s+(?:doğum tarihi|kuruluş tarihi)\s+(.+?)(?:\.|$)", re.I),
         lambda m: (m.group(1).strip() + " tarihi", m.group(2).strip())),
    ]

    def __init__(self, kb: KnowledgeBase):
        self.kb = kb

    def extract_facts(self, user_input: str, assistant_response: str) -> list:
        facts = []
        for pattern, mapper in self.FACT_PATTERNS:
            for m in pattern.finditer(user_input):
                t, f = mapper(m)
                if t and f and len(f) < 200:
                    facts.append((t, f))
        return facts

    def learn(self, user_input: str, assistant_response: str) -> int:
        """Konuşmadan fact çıkar + KB'ye ekle."""
        facts = self.extract_facts(user_input, assistant_response)
        for topic, fact in facts:
            self.kb.add(topic, fact, source="self_learner")
        return len(facts)


# ════════════════════════════════════════════════════════════════
# SELF-LEARNING CHAT — tüm modülleri birleştir
# ════════════════════════════════════════════════════════════════

class SelfLearningChat:
    """Norovox Nythos için kendi kendine öğrenen sohbet runtime'ı."""

    SYSTEM_BASE = (
        "Sen Norovox Nythos'sun — kendi kendine öğrenen Türkçe AI.\n\n"
        "Sahip olduğun yetenekler:\n"
        "- <think>...</think> derin düşünce blokları\n"
        "- Yerleşik araç çağrısı: <tool_call> bloğu\n"
        "- Kullanıcının öğrettiği yeni beceri ve bilgileri kalıcı hatırlama\n"
        "- Bilgi tabanından (KB) otomatik bağlam getirme\n\n"
        "# ÖĞRENDIKLERIM (KB'den)\n__KB__\n\n"
        "# KAZANDIĞIM BECERILER\n__SKILLS__\n\n"
        "Konuşma sırasında kullanıcı yeni bir şey öğretirse runtime otomatik kaydeder. "
        "Sen Türkçe yanıt ver, derinden düşün."
    )

    def __init__(self,
                 model_url: str = "http://localhost:8080/v1/chat/completions",
                 kb_path: str = "./norovox_kb.json",
                 skills_path: str = "./norovox_skills.json"):
        self.model_url = model_url
        self.kb = KnowledgeBase(kb_path)
        self.skills = SkillForge(skills_path)
        self.learner = SelfLearner(self.kb)

    def _build_system(self, query: str) -> str:
        kb_hits = self.kb.search(query, limit=3)
        kb_ctx = "\n".join(f"- {h}" for h in kb_hits) if kb_hits else "(henüz yok)"
        skill_list = self.skills.list_skills()[:3]
        skill_ctx = "\n".join(f"- {n} (kullanım: {u})" for n, u in skill_list) if skill_list else "(henüz yok)"
        return self.SYSTEM_BASE.replace("__KB__", kb_ctx).replace("__SKILLS__", skill_ctx)

    def sor(self, user_input: str) -> dict:
        """Tam pipeline: skill-match → LLM → learn."""
        result = {
            "input": user_input,
            "matched_skill": None,
            "new_skill": None,
            "learned_facts": 0,
            "response": "",
        }

        # 1) Skill match — daha önce öğretilen pattern var mı?
        matched = self.skills.match(user_input)
        if matched:
            result["matched_skill"] = matched["name"]

        # 2) Teaching detect — yeni skill öğretiliyor mu?
        teaching = self.skills.detect_teaching(user_input)
        if teaching:
            skill_id = self.skills.forge(teaching)
            result["new_skill"] = teaching.get("name", skill_id)

        # 3) LLM çağrısı (varsa)
        system_msg = self._build_system(user_input)
        # Burada gerçek LLM çağrısı yapılır — placeholder offline mod:
        try:
            import urllib.request
            body = json.dumps({
                "messages": [
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": user_input}
                ],
                "max_tokens": 600,
                "temperature": 0.5
            }).encode()
            req = urllib.request.Request(self.model_url, data=body,
                                          headers={"Content-Type": "application/json"})
            with urllib.request.urlopen(req, timeout=60) as r:
                data = json.loads(r.read())
            result["response"] = data["choices"][0]["message"]["content"]
        except Exception as e:
            result["response"] = f"[offline mod — model bağlantısı yok: {e}]"

        # 4) Konuşmadan öğren
        learned = self.learner.learn(user_input, result["response"])
        result["learned_facts"] = learned

        return result

    def stats(self) -> dict:
        return {
            "kb_facts": self.kb.size(),
            "skills_count": len(self.skills.skills),
            "skills_total_use": sum(s["use_count"] for s in self.skills.skills.values()),
        }


# ════════════════════════════════════════════════════════════════
# CLI TEST
# ════════════════════════════════════════════════════════════════

if __name__ == "__main__":
    import sys, tempfile

    print("== Norovox Nythos Self-Learning + Skill-Forge Test ==\n")

    # Geçici dosyalarla test
    with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
        kb_path = f.name
    with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
        skills_path = f.name

    chat = SelfLearningChat(kb_path=kb_path, skills_path=skills_path)

    # 1) Yeni skill öğret
    print("[1] Kullanıcı yeni skill öğretiyor...")
    r1 = chat.sor("bilgi_al(X) komutu demek 'X hakkında web ara + Türkçe özetle' anlamına geliyor")
    print(f"    New skill kaydedildi: {r1['new_skill']}")
    print(f"    Stats: {chat.stats()}\n")

    # 2) Aynı pattern'i kullan
    print("[2] Aynı pattern'le kullanım...")
    r2 = chat.sor("bilgi_al(Tesla şirketi)")
    print(f"    Matched skill: {r2['matched_skill']}")
    print(f"    Stats: {chat.stats()}\n")

    # 3) Fact öğret
    print("[3] Kullanıcı bir fact söylüyor...")
    r3 = chat.sor("benim adım Emre. Tercih ediyorum: kısa yanıtlar.")
    print(f"    KB'ye eklenen fact sayısı: {r3['learned_facts']}")
    print(f"    Stats: {chat.stats()}\n")

    # 4) KB hatırlama
    print("[4] KB'den hatırla...")
    facts = chat.kb.search("kullanıcı")
    for f in facts:
        print(f"    → {f}")

    print("\n[OK] Self-Learning + Skill-Forge çalışıyor")

    # Cleanup
    Path(kb_path).unlink(missing_ok=True)
    Path(skills_path).unlink(missing_ok=True)