crystalwindow 4.3__tar.gz → 4.5__tar.gz

{crystalwindow-4.3/crystalwindow.egg-info → crystalwindow-4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.3
+Version: 4.5
 Summary: A Tkinter powered window + GUI toolkit made by Crystal (MEEEEEE)! Easier apps, smoother UI and all-in-one helpers!
 Home-page: https://pypi.org/project/crystalwindow/
 Author: CrystalBallyHereXD

{crystalwindow-4.3 → crystalwindow-4.5}/crystalwindow/__init__.py

@@ -45,6 +45,7 @@ from .draw_tool import CrystalDraw
 from .fun_helpers import random_name, DebugOverlay, random_color, random_palette, lerp
 from .camera import Camera
 from .color_handler import Colors, Color
+from .websearch import WebSearchResult, WebSearch
 
 # === 3D Engine ===
 from .crystal3d import CW3D
@@ -52,6 +53,9 @@ from .crystal3d import CW3D
 # === AI Engine ===
 from .ai import AI
 
+# === Server Manager ===
+from .cw_client import CWClient
+
 __all__ = [
     # --- Core ---
     "Window", "Sprite", "TileMap", "Player", "Gravity", "FileHelper", "Mathematics",
@@ -84,11 +88,14 @@ __all__ = [
     "gradient_rect", "CameraShake", "DrawHelper", "DrawTextManager", "CrystalDraw", 
 
     # --- Misc ---
-    "random_name", "DebugOverlay", "Camera", "Colors", "Color", "random_palette", "lerp"
+    "random_name", "DebugOverlay", "Camera", "Colors", "Color", "random_palette", "lerp", "WebSearchResult", "WebSearch",
 
     # --- 3D ---
     "CW3D",
 
     # --- AI ---
     "AI",
+
+    # --- Server Client ---
+    "CWClient",
 ]

crystalwindow-4.5/crystalwindow/ai.py

@@ -0,0 +1,314 @@
+# ==========================================================
+# CrystalAI v0.7 — Stabilized & Corrected Engine
+# ----------------------------------------------------------
+
+import os
+import ast
+import difflib
+import requests
+import json
+from typing import Optional, Dict, Any
+
+
+# ==========================================================
+# Response Wrapper
+# ==========================================================
+class CrystalAIResponse:
+    def __init__(self, text: str, meta: Optional[Dict[str, Any]] = None):
+        self.text = text
+        self.meta = meta or {}
+
+    def __str__(self):
+        return self.text
+
+
+# ==========================================================
+# MAIN ENGINE
+# ==========================================================
+class AI:
+    DEFAULT_MODEL = "llama-3.1-70b-versatile"
+    DEFAULT_PERSONALITY = (
+        "You are CrystalWindow AI. You help users with Python code, "
+        "debugging, error analysis, documentation, and file analysis. "
+        "Be friendly, technical, clear, and precise."
+    )
+
+    PLACEHOLDER_KEY = "NO_KEY_PROVIDED"
+
+    # ------------------------------------------------------
+    def __init__(self, key=None, model=None):
+
+        # --- KEY VALIDATION ---
+        # If no key passed try common environment variables (makes key optional)
+        if not key:
+            key = (
+                os.environ.get("CRYSTALAI_API_KEY")
+                or os.environ.get("GROQ_API_KEY")
+                or os.environ.get("OPENAI_API_KEY")
+                or os.environ.get("API_KEY")
+            )
+            if key:
+                key = str(key).strip()
+
+        if not key or len(str(key).strip()) == 0:
+            print("[CrystalAI] No API key provided → using offline mode.")
+            self.key = None  # forces offline fallback
+            self.force_local = True
+        else:
+            self.key = key
+            self.force_local = False
+
+        # --- MODEL VALIDATION ---
+        # If model is omitted (None) use default silently; only warn if an invalid model is explicitly passed
+        if model is None:
+            self.model = self.DEFAULT_MODEL
+        elif not isinstance(model, str) or len(model) < 3:
+            print("[CrystalAI] Unknown model → using default.")
+            self.model = self.DEFAULT_MODEL
+        else:
+            self.model = model
+
+        self.personality = self.DEFAULT_PERSONALITY
+        self.memory = []
+        self.use_memory = True
+        self.library_context = ""
+
+    # ==========================================================
+    # PERSONALITY
+    # ==========================================================
+    def set_personality(self, txt):
+        if not isinstance(txt, str) or len(txt.strip()) < 10:
+            print("[CrystalAI] Personality too short → reverting to default.")
+            self.personality = self.DEFAULT_PERSONALITY
+            return
+
+        if len(txt) > 3000:
+            print("[CrystalAI] Personality too long → using default.")
+            self.personality = self.DEFAULT_PERSONALITY
+            return
+
+        self.personality = txt.strip()
+
+    # ==========================================================
+    # LIBRARY INGESTION
+    # ==========================================================
+    def index_library(self, folder):
+        """
+        Load all Python files as context for smarter answers.
+        """
+        if not os.path.exists(folder):
+            print("[CrystalAI] Library folder not found.")
+            return
+
+        collected = []
+        for root, _, files in os.walk(folder):
+            for f in files:
+                if f.endswith(".py"):
+                    try:
+                        p = os.path.join(root, f)
+                        with open(p, "r", encoding="utf8") as fp:
+                            collected.append(
+                                f"# FILE: {p}\n{fp.read()}\n\n"
+                            )
+                    except:
+                        pass
+
+        self.library_context = "\n".join(collected)[:120_000]   # trimmed
+
+    # ==========================================================
+    # FILE READER
+    # ==========================================================
+    def _read_file(self, path):
+        if not path:
+            return None
+        if not os.path.exists(path):
+            return f"[CrystalAI] file not found: {path}"
+        try:
+            with open(path, "r", encoding="utf8") as f:
+                return f.read()
+        except:
+            return "[CrystalAI] could not read file."
+
+    # ==========================================================
+    # PROMPT BUILDER
+    # ==========================================================
+    def _build_prompt(self, user_text, file_data):
+        final = (
+            f"[SYSTEM]\n{self.personality}\n\n"
+            f"[USER]\n{user_text}\n\n"
+        )
+
+        if self.use_memory and self.memory:
+            final += "[MEMORY]\n"
+            for m in self.memory[-6:]:
+                final += f"User: {m['user']}\nAI: {m['ai']}\n"
+            final += "\n"
+
+        if self.library_context:
+            final += f"[LIBRARY]\n{self.library_context}\n\n"
+
+        if file_data and not file_data.startswith("[CrystalAI]"):
+            final += f"[FILE]\n{file_data}\n\n"
+
+        return final[:190_000]   # safety limit
+
+    def _save_memory(self, user, ai):
+        self.memory.append({"user": user, "ai": ai})
+        if len(self.memory) > 60:
+            self.memory.pop(0)
+
+    # ==========================================================
+    # LOCAL FALLBACK AI
+    # ==========================================================
+    def _local_ai(self, user_text, file_data):
+        """
+        Much cleaner, more reliable fallback engine.
+        """
+
+        # --- AST SECTION ---
+        if file_data and not file_data.startswith("[CrystalAI]"):
+            try:
+                ast.parse(file_data)
+                return (
+                    "[LocalAI] File parsed successfully — no syntax errors.\n"
+                    "Ask for refactoring, explanation, or improvements."
+                )
+            except SyntaxError as se:
+                snippet = self._snippet(file_data, se.lineno)
+                return (
+                    "[LocalAI] SyntaxError found:\n"
+                    f"• {se.msg}\n"
+                    f"• Line {se.lineno}\n\n"
+                    f"{snippet}"
+                )
+
+        # --- GENERIC HELP ---
+        lower = user_text.lower()
+        if "python" in lower or "fix" in lower or "error" in lower:
+            return (
+                "[LocalAI] Offline mode: I can help with general Python logic.\n"
+                "If you provide a file, I can analyze it using AST."
+            )
+
+        return "[LocalAI] Offline mode active — limited responses available."
+
+    # ==========================================================
+    # MAIN "ASK" FUNCTION
+    # ==========================================================
+    def ask(self, text, file=None):
+        file_data = self._read_file(file)
+        prompt = self._build_prompt(text, file_data)
+
+        # If no API key → offline only
+        if self.force_local:
+            resp = self._local_ai(text, file_data)
+            self._save_memory(text, resp)
+            return CrystalAIResponse(resp)
+
+        # Online mode
+        try:
+            url = "https://api.groq.com/openai/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.key}",
+                "Content-Type": "application/json"
+            }
+
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": self.personality},
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": 0.3
+            }
+
+            r = requests.post(url, json=payload, headers=headers, timeout=8)
+            data = r.json()
+
+            if "error" in data:
+                raise RuntimeError(data["error"])
+
+            resp = data["choices"][0]["message"]["content"]
+
+        except Exception:
+            resp = self._local_ai(text, file_data)
+
+        self._save_memory(text, resp)
+        return CrystalAIResponse(resp)
+
+    # ==========================================================
+    # TERMINAL HELPER
+    # ==========================================================
+    def ask_t(self, text, file=None):
+        return self.ask(f"[TERMINAL] {text}", file)
+
+    # ==========================================================
+    # AUTO FIX CODE
+    # ==========================================================
+    def fix_code(self, file_path):
+        orig = self._read_file(file_path)
+
+        if not orig or orig.startswith("[CrystalAI]"):
+            return CrystalAIResponse(orig or "[CrystalAI] file missing")
+
+        try:
+            ast.parse(orig)
+            return CrystalAIResponse("[AI] No syntax errors found.")
+        except SyntaxError as se:
+            fixed, notes = self._simple_fix(orig, se)
+            diff = self._make_diff(orig, fixed)
+            msg = "[AI] Auto-fix result:\n" + "\n".join(notes) + "\n\n" + diff
+            return CrystalAIResponse(msg, {"diff": diff, "notes": notes})
+
+    # ==========================================================
+    # SIMPLE AUTO-FIX ENGINE
+    # ==========================================================
+    def _simple_fix(self, src, err):
+        notes = []
+        lines = src.splitlines()
+        msg = getattr(err, "msg", "")
+        lineno = err.lineno or 0
+
+        if "expected" in msg and ":" in msg:
+            if 1 <= lineno <= len(lines):
+                l = lines[lineno - 1].rstrip()
+                if not l.endswith(":"):
+                    lines[lineno - 1] = l + ":"
+                    notes.append("[fix] added missing ':'")
+                    candidate = "\n".join(lines)
+                    try:
+                        ast.parse(candidate)
+                        return candidate, notes
+                    except:
+                        pass
+
+        notes.append("[info] auto-fix could not fix the error")
+        return src, notes
+
+    # ==========================================================
+    # DIFF HELPER
+    # ==========================================================
+    def _make_diff(self, old, new):
+        return "\n".join(
+            difflib.unified_diff(
+                old.splitlines(), new.splitlines(),
+                fromfile="old", tofile="new", lineterm=""
+            )
+        )
+
+    # ==========================================================
+    # SNIPPET HELPER
+    # ==========================================================
+    def _snippet(self, src, lineno, ctx=2):
+        lines = src.splitlines()
+        start = max(0, lineno - ctx - 1)
+        end = min(len(lines), lineno + ctx)
+        out = []
+        for i in range(start, end):
+            mark = "->" if (i + 1) == lineno else "  "
+            out.append(f"{mark} {i+1:4}: {lines[i]}")
+        return "\n".join(out)
+
+# ==========================================================
+# END OF ENGINE
+# ==========================================================

crystalwindow-4.5/crystalwindow/cw_client.py

@@ -0,0 +1,95 @@
+# cw_client.py
+# pip install websockets
+import asyncio
+import websockets
+import json
+import threading
+import time
+
+class CWClient:
+    """
+    Lightweight client wrapper. Usage:
+      c = CWClient("MyName", "ws://host:8765")
+      c.on_event = lambda ev: print("ev", ev)
+      c.start()
+      c.move(x,y)
+      c.chat("hi")
+    """
+    def __init__(self, pid, uri="ws://127.0.0.1:8765"):
+        self.pid = pid
+        self.uri = uri
+        self._send_q = asyncio.Queue()
+        self.on_event = None   # callback for incoming events: fn(dict)
+        self._running = False
+        self._loop_thread = None
+
+    async def _run(self):
+        try:
+            async with websockets.connect(self.uri) as ws:
+                # send join
+                await ws.send(json.dumps({"type":"join","id":self.pid}))
+                self._running = True
+                sender_task = asyncio.create_task(self._sender(ws))
+                try:
+                    async for raw in ws:
+                        try:
+                            data = json.loads(raw)
+                        except:
+                            continue
+                        if self.on_event:
+                            # run callback in same thread (safe)
+                            try:
+                                self.on_event(data)
+                            except Exception as cb_e:
+                                # swallow callback errors
+                                print("on_event callback error:", cb_e)
+                finally:
+                    sender_task.cancel()
+        except Exception as e:
+            # notify user on connection lost
+            if self.on_event:
+                try:
+                    self.on_event({"type":"sys","msg":f"connection_lost:{e}"})
+                except:
+                    pass
+        finally:
+            self._running = False
+
+    async def _sender(self, ws):
+        while True:
+            try:
+                obj = await self._send_q.get()
+                await ws.send(json.dumps(obj))
+            except Exception:
+                break
+
+    def start(self):
+        if self._loop_thread and self._loop_thread.is_alive():
+            return
+        def target():
+            asyncio.run(self._run())
+        self._loop_thread = threading.Thread(target=target, daemon=True)
+        self._loop_thread.start()
+        # give a bit of time to connect
+        time.sleep(0.05)
+
+    def send(self, obj):
+        # enqueue safely from any thread
+        async def push():
+            await self._send_q.put(obj)
+        try:
+            loop = asyncio.get_running_loop()
+            # if main thread has a loop, schedule
+            asyncio.run_coroutine_threadsafe(push(), loop)
+        except RuntimeError:
+            # no running loop in this thread: create a tiny loop to push
+            def run_push():
+                asyncio.run(push())
+            threading.Thread(target=run_push, daemon=True).start()
+
+    # convenience APIs
+    def move(self, x, y):
+        self.send({"type":"move","id":self.pid,"x":int(x),"y":int(y)})
+
+    def chat(self, msg):
+        self.send({"type":"chat","id":self.pid,"msg":str(msg)})

crystalwindow-4.5/crystalwindow/websearch.py

@@ -0,0 +1,233 @@
+"""
+CrystalWindow WebSearch module — Google (Serper.dev) Edition
+"""
+
+from __future__ import annotations
+import requests
+import webbrowser
+from dataclasses import dataclass
+from typing import List, Tuple, Optional, Any
+
+# Optional Qt integration
+try:
+    from PySide6.QtWidgets import (
+        QWidget, QVBoxLayout, QLineEdit, QPushButton, QTextEdit,
+        QListWidget, QListWidgetItem, QLabel, QHBoxLayout
+    )
+    from PySide6.QtCore import Qt, QUrl
+    from PySide6.QtGui import QDesktopServices
+    PYSIDE6_AVAILABLE = True
+except Exception:
+    PYSIDE6_AVAILABLE = False
+
+
+# --------------------------
+# Data result structure
+# --------------------------
+
+@dataclass
+class WebSearchResult:
+    text: str
+    links: List[Tuple[str, str]]  # (title, url)
+    raw: Any = None
+
+
+# --------------------------
+# Main WebSearch class
+# --------------------------
+
+class WebSearch:
+    """ Real Web Search helper for CrystalWindow using Google (Serper.dev). """
+
+    # --- DuckDuckGo Instant Answer (kept for fallback) ---
+    DUCKDUCKGO_INSTANT = "https://api.duckduckgo.com/"
+
+    # --- Google Search (Serper.dev) ---
+    SERPER_URL = "https://google.serper.dev/search"
+    SERPER_API_KEY = "a8e02281a0c3b58bb29a3731b6a2aec1d8d8a487"  # <<<<<<<< REPLACE THIS
+
+    # --------------------------------------------------
+    # DuckDuckGo Instant Answer (old API)
+    # --------------------------------------------------
+    @classmethod
+    def _duckduckgo_instant(cls, query: str) -> WebSearchResult:
+        params = {
+            "q": query,
+            "format": "json",
+            "no_html": 1,
+            "no_redirect": 1,
+        }
+        try:
+            r = requests.get(cls.DUCKDUCKGO_INSTANT, params=params, timeout=8)
+            r.raise_for_status()
+        except Exception as e:
+            return WebSearchResult(text=f"DuckDuckGo error: {e}", links=[])
+
+        data = r.json()
+        abstract = data.get("AbstractText") or data.get("Abstract") or ""
+        links: List[Tuple[str, str]] = []
+
+        if data.get("AbstractURL"):
+            links.append((data.get("Heading", "Result"), data["AbstractURL"]))
+
+        def extract_related(rt):
+            if isinstance(rt, dict):
+                if rt.get("FirstURL") and rt.get("Text"):
+                    links.append((rt["Text"], rt["FirstURL"]))
+                for key in ("Topics", "RelatedTopics"):
+                    if isinstance(rt.get(key), list):
+                        for sub in rt[key]:
+                            extract_related(sub)
+            elif isinstance(rt, list):
+                for item in rt:
+                    extract_related(item)
+
+        extract_related(data.get("RelatedTopics", []))
+        if not abstract and links:
+            abstract = "\n".join([t for t, _ in links[:3]])
+
+        return WebSearchResult(text=abstract.strip(), links=links, raw=data)
+
+    # --------------------------------------------------
+    # Google Search via Serper.dev (NEW)
+    # --------------------------------------------------
+    @classmethod
+    def _google_serper(cls, query: str) -> WebSearchResult:
+        headers = {
+            "X-API-KEY": cls.SERPER_API_KEY,
+            "Content-Type": "application/json"
+        }
+        body = {"q": query}
+
+        try:
+            r = requests.post(cls.SERPER_URL, headers=headers, json=body, timeout=8)
+            r.raise_for_status()
+        except Exception as e:
+            return WebSearchResult(text=f"Google search error: {e}", links=[])
+
+        data = r.json()
+
+        links = []
+        summary_parts = []
+
+        for item in data.get("organic", []):
+            title = item.get("title", "Untitled")
+            url = item.get("link", "")
+            snippet = item.get("snippet", "")
+
+            links.append((title, url))
+            if snippet:
+                summary_parts.append(snippet)
+
+        summary = "\n".join(summary_parts[:3]).strip()
+        if not summary:
+            summary = "(no summary)"
+
+        return WebSearchResult(summary, links, data)
+
+    # --------------------------------------------------
+    # Main public search()
+    # --------------------------------------------------
+    @classmethod
+    def search(cls, query: str, engine: str = "google") -> WebSearchResult:
+        if not query or not query.strip():
+            return WebSearchResult(text="", links=[])
+
+        q = query.strip().lower()
+        engine = engine.lower()
+
+        if engine == "google":
+            return cls._google_serper(q)
+
+        if engine == "duckduckgo":
+            return cls._duckduckgo_instant(q)
+
+        return WebSearchResult(text=f"Unknown engine '{engine}'", links=[])
+
+    # --------------------------------------------------
+    # URL opener
+    # --------------------------------------------------
+    @staticmethod
+    def open_url(url: str) -> None:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+
+    # --------------------------------------------------
+    # Optional PySide6 GUI
+    # --------------------------------------------------
+    if PYSIDE6_AVAILABLE:
+        class _CWWebTab(QWidget):
+            def __init__(self, parent=None):
+                super().__init__(parent)
+                self.setWindowTitle("WebSearch")
+
+                layout = QVBoxLayout(self)
+
+                # Search bar
+                bar = QHBoxLayout()
+                self.qbox = QLineEdit()
+                self.qbox.setPlaceholderText("Search the web...")
+                btn = QPushButton("Search")
+                btn.clicked.connect(self._do_search)
+                bar.addWidget(self.qbox)
+                bar.addWidget(btn)
+                layout.addLayout(bar)
+
+                # Summary text
+                self.summary = QTextEdit()
+                self.summary.setReadOnly(True)
+                self.summary.setFixedHeight(150)
+                layout.addWidget(self.summary)
+
+                # Links list
+                self.links = QListWidget()
+                self.links.itemActivated.connect(self._open_item)
+                layout.addWidget(self.links)
+
+                self.note = QLabel("Powered by Google (Serper.dev) API")
+                self.note.setAlignment(Qt.AlignCenter)
+                layout.addWidget(self.note)
+
+            def _populate(self, result: WebSearchResult):
+                self.summary.setPlainText(result.text)
+                self.links.clear()
+                for t, u in result.links:
+                    item = QListWidgetItem(f"{t}\n{u}")
+                    item.setData(Qt.UserRole, u)
+                    self.links.addItem(item)
+
+            def _open_item(self, item: QListWidgetItem):
+                url = item.data(Qt.UserRole)
+                if url:
+                    QDesktopServices.openUrl(QUrl(url))
+
+            def _do_search(self):
+                q = self.qbox.text().strip()
+                if not q:
+                    self.summary.setPlainText("Type something to search.")
+                    return
+                self.summary.setPlainText("Searching...")
+                res = WebSearch.search(q, engine="google")
+                self._populate(res)
+
+        @classmethod
+        def register_cw_tab(cls, window):
+            try:
+                tab = cls._CWWebTab()
+                if hasattr(window, "add_tab"):
+                    window.add_tab("WebSearch", tab)
+                elif hasattr(window, "addTab"):
+                    window.addTab(tab, "WebSearch")
+                else:
+                    if hasattr(window, "setCentralWidget"):
+                        window.setCentralWidget(tab)
+                return tab
+            except Exception:
+                return None
+
+    else:
+        @classmethod
+        def register_cw_tab(cls, window):
+            return None

{crystalwindow-4.3 → crystalwindow-4.5}/crystalwindow/window.py

@@ -1,6 +1,8 @@
 # === Window Management (tkinter version) ===
 import tkinter as tk
 import base64, io, os, sys, contextlib, time
+from .websearch import WebSearch
+
 
 # === Boot ===
 main_file = os.path.basename(sys.argv[0])
@@ -117,6 +119,8 @@ class Window:
         self._key_last = {}  # new dict to store last press time per key
         self._key_cooldown = 0.00001  # seconds, tweak for faster/slower input
 
+        WebSearch.register_cw_tab(self)
+
         # === Event bindings ===
         self.root.bind("<KeyPress>", self._on_keydown)
         self.root.bind("<KeyRelease>", self._on_keyup)
@@ -163,7 +167,8 @@ class Window:
 
     def mouse_pressed(self, button=1):
         return self._mouse_pressed[button - 1]
-
+    def add_tab(self, title, widget):
+        self.tabs.addTab(widget, title)
     # === Drawing ===
     def fill(self, color):
         """Fill background with a color"""

{crystalwindow-4.3 → crystalwindow-4.5/crystalwindow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.3
+Version: 4.5
 Summary: A Tkinter powered window + GUI toolkit made by Crystal (MEEEEEE)! Easier apps, smoother UI and all-in-one helpers!
 Home-page: https://pypi.org/project/crystalwindow/
 Author: CrystalBallyHereXD

{crystalwindow-4.3 → crystalwindow-4.5}/crystalwindow.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ crystalwindow/clock.py
 crystalwindow/collision.py
 crystalwindow/color_handler.py
 crystalwindow/crystal3d.py
+crystalwindow/cw_client.py
 crystalwindow/draw_helpers.py
 crystalwindow/draw_rects.py
 crystalwindow/draw_text_helper.py
@@ -25,6 +26,7 @@ crystalwindow/player.py
 crystalwindow/sprites.py
 crystalwindow/tilemap.py
 crystalwindow/ver_warner.py
+crystalwindow/websearch.py
 crystalwindow/window.py
 crystalwindow.egg-info/PKG-INFO
 crystalwindow.egg-info/SOURCES.txt

{crystalwindow-4.3 → crystalwindow-4.5}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="crystalwindow",
-    version="4.3",  # Force metadata refresh
+    version="4.5",  # Force metadata refresh
     packages=find_packages(include=["crystalwindow", "crystalwindow.*"]),
 
     include_package_data=True,  # include package_data files

crystalwindow-4.3/crystalwindow/ai.py

@@ -1,329 +0,0 @@
-# ==========================================================
-# CrystalAI v0.7 — Self-Contained Symbolic Engine
-# ----------------------------------------------------------
-# Focus: Pure Python 'thinking' (Knowledge Graph/Rule-Based)
-# Changes:
-#   - Refactored _local_ai to _symbolic_engine
-#   - Added a simple knowledge base (K-Graph)
-#   - Added context/intent matching for 'thinking'
-#   - Removed Groq/External API integration
-# ==========================================================
-
-import os
-import ast
-import difflib
-from typing import Optional, Dict, Any, List
-# Removed requests and groq imports as they are no longer needed
-# Removed import groq (if it was present)
-
-# ==========================================================
-# Response Wrapper
-# ==========================================================
-class CrystalAIResponse:
-    def __init__(self, text: str, meta: Optional[Dict[str, Any]] = None):
-        self.text = text
-        self.meta = meta or {}
-
-    def __str__(self):
-        return self.text
-
-
-# ==========================================================
-# MAIN ENGINE
-# ==========================================================
-class AI:
-    DEFAULT_MODEL = "PURE_SYMBOLIC"
-    DEFAULT_PERSONALITY = (
-        "You are CrystalMind AI, a completely self-coded, symbolic engine. "
-        "I process information using an internal rule-base and knowledge graph. "
-        "I can reason about simple code and defined concepts."
-    )
-    # Key is ignored in this self-contained mode, but kept for signature consistency
-    PLACEHOLDER_KEY = "PURE_SYMBOLIC_KEY_IGNORED" 
-
-    # ------------------------------------------------------
-    def __init__(self, key=None, model=None):
-        # --- KEY/MODEL SETUP (for consistency, though ignored) ---
-        self.key = self.PLACEHOLDER_KEY
-        self.model = self.DEFAULT_MODEL
-        self.personality = self.DEFAULT_PERSONALITY
-
-        # --- PURE AI KNOWLEDGE BASE (The 'Thinking' Core) ---
-        self.knowledge_graph: Dict[str, Any] = self._build_knowledge_graph()
-
-        # v0.4 memory system (optional)
-        self.memory: List[Dict[str, str]] = []
-        self.use_memory = True
-
-        # v0.4 toggle for forcing local engine
-        self.force_local = True # Always True for a self-contained AI
-
-        # Library knowledge (loaded .py files)
-        self.library_context = ""
-
-    # ==========================================================
-    # PERSONALITY
-    # ==========================================================
-    def set_personality(self, txt):
-        if not isinstance(txt, str) or len(txt.strip()) < 10:
-            print("Oops! thats not how to use it—reverting to default.")
-            self.personality = self.DEFAULT_PERSONALITY
-            return
-
-        if len(txt) > 3000:
-            print("Oops, personality too long → using default.")
-            self.personality = self.DEFAULT_PERSONALITY
-            return
-
-        self.personality = txt.strip()
-
-    # ==========================================================
-    # LIBRARY INGESTION
-    # ==========================================================
-    def index_library(self, folder):
-        """
-        Load all Python files as context for smarter answers.
-        (Context is used in prompt but processed by local engine's rules)
-        """
-        out = []
-        if not os.path.exists(folder):
-            print("[CrystalAI] Library folder not found.")
-            return
-
-        for root, _, files in os.walk(folder):
-            for f in files:
-                if f.endswith(".py"):
-                    try:
-                        path = os.path.join(root, f)
-                        with open(path, "r", encoding="utf8") as fp:
-                            out.append(f"# FILE: {path}\n" + fp.read() + "\n\n")
-                    except:
-                        pass
-
-        self.library_context = "\n".join(out)
-
-    # ==========================================================
-    # FILE READER
-    # ==========================================================
-    def _read_file(self, path):
-        if not path:
-            return None
-        if not os.path.exists(path):
-            return f"[CrystalAI] file not found: {path}"
-        try:
-            with open(path, "r", encoding="utf8") as f:
-                return f.read()
-        except:
-            return "[CrystalAI] couldnt read file."
-
-    # ==========================================================
-    # PROMPT BUILDER (Unified)
-    # ==========================================================
-    def _build_prompt(self, user_text, file_data=None):
-        final = (
-            f"[SYSTEM]\n{self.personality}\n\n"
-            f"[USER]\n{user_text}\n\n"
-        )
-
-        if self.use_memory and self.memory:
-            final += "[MEMORY]\n"
-            for m in self.memory[-6:]:
-                final += f"User: {m['user']}\nAI: {m['ai']}\n"
-            final += "\n"
-
-        if self.library_context:
-            final += f"[LIBRARY]\n{self.library_context}\n\n"
-
-        if file_data:
-            final += f"[FILE]\n{file_data}\n\n"
-
-        return final
-
-    def _save_memory(self, user, ai):
-        self.memory.append({"user": user, "ai": ai})
-        if len(self.memory) > 60:
-            self.memory.pop(0)
-
-    # ==========================================================
-    # PURE AI KNOWLEDGE BASE (Self-Contained 'Knowledge')
-    # ==========================================================
-    def _build_knowledge_graph(self) -> Dict[str, Any]:
-        """
-        Defines the internal knowledge the pure AI can reason with.
-        """
-        return {
-            "python": {
-                "desc": "A high-level, interpreted programming language.",
-                "keywords": ["language", "interpreted", "high-level"],
-                "syntax": {
-                    "if_statement": "if condition: ... else: ...",
-                    "loop": "for item in iterable: ..."
-                }
-            },
-            "ast": {
-                "desc": "Abstract Syntax Tree. Used for parsing code structure.",
-                "keywords": ["parsing", "code", "structure", "tree"]
-            },
-            "fix_code": {
-                "rule": "look for SyntaxError, especially missing colons or mismatched brackets",
-                "keywords": ["fix", "error", "bug", "syntax"]
-            }
-        }
-
-    # ==========================================================
-    # PURE AI 'THINKING' ENGINE (Replaces _local_ai)
-    # ==========================================================
-    def _symbolic_engine(self, prompt: str, file_data: Optional[str]) -> str:
-        """
-        Simulates 'thinking' using only internal rules and the knowledge graph.
-        """
-        output = ["[SymbolicEngine] Processing request..."]
-        lower_prompt = prompt.lower()
-
-        # --- Stage 1: File Analysis (Real Python AST) ---
-        if file_data and not file_data.startswith("[CrystalAI]"):
-            output.append("\n[Stage 1: Code Parsing]")
-            try:
-                ast.parse(file_data)
-                output.append("✅ **No Syntax Errors Detected** (via AST).")
-                output.append("The code is structurally sound. Ask for refactoring or explanation.")
-                return "\n".join(output)
-            except SyntaxError as se:
-                # Use the built-in fix rule from the knowledge graph
-                fix_rule = self.knowledge_graph["fix_code"]["rule"]
-                lineno = se.lineno or 0
-                offset = se.offset or 0
-                msg = (
-                    f"❌ **SyntaxError Detected** (via AST):\n"
-                    f"• Message: {se.msg}\n"
-                    f"• Line: {lineno}\n"
-                    f"• Column: {offset}\n"
-                    f"• Rule suggestion: {fix_rule}"
-                )
-                output.append(msg)
-                output.append(self._snippet(file_data, lineno))
-                return "\n".join(output)
-
-        # --- Stage 2: Knowledge Graph Lookup (Rule-Based Reasoning) ---
-        output.append("\n[Stage 2: Symbolic Lookup]")
-
-        # Check for concepts the AI 'knows'
-        found_concept = False
-        for key, knowledge in self.knowledge_graph.items():
-            if key in lower_prompt or any(k in lower_prompt for k in knowledge.get("keywords", [])):
-                if key == "fix_code": continue # Already handled in Stage 1
-
-                output.append(f"🧠 Found Concept: **{key.upper()}**")
-                output.append(f"Description: {knowledge.get('desc', 'No detailed description.')}")
-                
-                # Simple reasoning about related syntax
-                if 'syntax' in knowledge:
-                    output.append("Related Syntax:")
-                    for syn, code in knowledge['syntax'].items():
-                        output.append(f"  - {syn.replace('_', ' ')}: `{code}`")
-                
-                found_concept = True
-                break
-        
-        if not found_concept:
-            output.append("❓ Concept Unknown: I am limited to my internal knowledge base (Python, AST, Fix Code).")
-            output.append("Please ask about a defined concept or provide a file for AST analysis.")
-
-
-        return "\n".join(output)
-
-    # ==========================================================
-    # ASK (Pure Symbolic Engine)
-    # ==========================================================
-    def ask(self, text, file=None):
-        file_data = self._read_file(file)
-        prompt = self._build_prompt(text, file_data)
-        
-        # We skip the external API call entirely, relying on the symbolic engine
-        resp = self._symbolic_engine(prompt, file_data)
-
-        self._save_memory(text, resp)
-        return CrystalAIResponse(resp)
-
-    # ==========================================================
-    # ASK (terminal)
-    # ==========================================================
-    def ask_t(self, text, file=None):
-        return self.ask(f"[TERMINAL] {text}", file)
-
-    # ==========================================================
-    # AUTO FIX CODE (v0.4)
-    # ==========================================================
-    def fix_code(self, file_path):
-        orig = self._read_file(file_path)
-
-        if not orig or orig.startswith("[CrystalAI]"):
-            return CrystalAIResponse(orig or "[CrystalAI] file missing")
-
-        try:
-            ast.parse(orig)
-            return CrystalAIResponse("[AI] No syntax errors found.")
-        except SyntaxError as se:
-            fixed, notes = self._simple_fix(orig, se)
-            diff = self._make_diff(orig, fixed)
-            pretty = "[AI] Auto-fix result:\n" + "\n".join(notes) + "\n\n" + diff
-            return CrystalAIResponse(pretty, {"diff": diff, "notes": notes})
-
-    # ==========================================================
-    # SIMPLE AUTO-FIX ENGINE
-    # ==========================================================
-    def _simple_fix(self, src, syntax_error):
-        notes = []
-        lines = src.splitlines()
-        msg = getattr(syntax_error, "msg", "")
-        lineno = syntax_error.lineno or 0
-
-        # missing colon
-        if "expected" in msg and ":" in msg:
-            if 1 <= lineno <= len(lines):
-                line = lines[lineno - 1].rstrip()
-                if not line.endswith(":"):
-                    lines[lineno - 1] = line + ":"
-                    notes.append("[fix] added missing ':'")
-                    candidate = "\n".join(lines)
-                    try:
-                        ast.parse(candidate)
-                        return candidate, notes
-                    except:
-                        pass
-
-        # fallback
-        notes.append("[info] auto-fix could not fix everything")
-        return src, notes
-
-    # ==========================================================
-    # DIFF UTIL
-    # ==========================================================
-    def _make_diff(self, old, new):
-        return "\n".join(
-            difflib.unified_diff(
-                old.splitlines(),
-                new.splitlines(),
-                fromfile="old",
-                tofile="new",
-                lineterm=""
-            )
-        )
-
-    # ==========================================================
-    # SNIPPET HELPER
-    # ==========================================================
-    def _snippet(self, src, lineno, ctx=2):
-        lines = src.splitlines()
-        start = max(0, lineno - ctx - 1)
-        end = min(len(lines), lineno + ctx)
-        out = []
-        for i in range(start, end):
-            mark = "->" if (i + 1) == lineno else "  "
-            # Adjusted line formatting for clarity
-            out.append(f"{mark} {i+1:<4}: {lines[i]}")
-        return "\n".join(out)
-
-# ==========================================================
-# END OF PURE SYMBOLIC ENGINE
-# ==========================================================