socratic-debug 0.0.2__tar.gz → 0.0.4__tar.gz

{socratic_debug-0.0.2/socratic_debug.egg-info → socratic_debug-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socratic-debug
-Version: 0.0.2
+Version: 0.0.4
 Summary: Autonomous pedagogical debugging mentor powered by LangGraph, Rich, and LangSmith
 Author: Mohamed Elawakey
 Requires-Python: >=3.10

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "socratic-debug"
-version = "0.0.2"
+version = "0.0.4"
 description = "Autonomous pedagogical debugging mentor powered by LangGraph, Rich, and LangSmith"
 authors = [{ name = "Mohamed Elawakey" }]
 readme = "README.md"
@@ -20,7 +20,7 @@ dependencies = [
 ]
 
 [project.scripts]
-socratic = "src.cli:main"
+socratic = "socratic:main"
 
 [tool.setuptools]
 py-modules = ["socratic"]

socratic_debug-0.0.4/socratic.py

@@ -0,0 +1,28 @@
+"""Socratic Debug — Autonomous pedagogical debugging mentor."""
+
+from src.hook import install as _core_install
+from src.agent.runner import run_socratic_agent
+
+
+def _wire_ui():
+    try:
+        from ui.adapter import register_ui_adapter
+        register_ui_adapter()
+    except Exception:
+        pass
+
+
+def install():
+    """Binds UI presentation adapter and installs system exception hook."""
+    _wire_ui()
+    _core_install()
+
+
+def main():
+    """Primary CLI composition root: connects UI adapter to core and executes CLI."""
+    _wire_ui()
+    from src.cli import main as _cli_main
+    _cli_main()
+
+
+__all__ = ["install", "run_socratic_agent", "main"]

{socratic_debug-0.0.2 → socratic_debug-0.0.4/socratic_debug.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socratic-debug
-Version: 0.0.2
+Version: 0.0.4
 Summary: Autonomous pedagogical debugging mentor powered by LangGraph, Rich, and LangSmith
 Author: Mohamed Elawakey
 Requires-Python: >=3.10

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/socratic_debug.egg-info/SOURCES.txt

@@ -12,8 +12,10 @@ src/__init__.py
 src/cli.py
 src/config_creator.py
 src/config_template.py
+src/events.py
 src/extractor.py
 src/hook.py
+src/watcher.py
 src/agent/runner.py
 src/agent/graph/graph.py
 src/agent/llm/factory.py
@@ -32,8 +34,9 @@ src/agent/prompts/questioner_prompt.py
 src/agent/prompts/solution_prompt.py
 src/agent/state/state.py
 src/utils/read_yaml.py
-test/test_hock.py
+test/test_hook.py
 ui/__init__.py
+ui/adapter.py
 ui/app.py
 ui/bidi.py
 ui/console.py

socratic_debug-0.0.4/socratic_debug.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+socratic = socratic:main

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/agent/nodes/evaluate_node.py

@@ -1,19 +1,31 @@
 from src.agent.prompts.evaluation_prompt import EvaluationPrompt
 from src.agent.state.state import SocraticAgentState
 from src.agent.llm.factory import LLMFactory
+from src.events import EventBus
 
-from ui.views import SocraticUI
 
 class EvaluationNode:
     @staticmethod
     def evaluation_node(state: SocraticAgentState):
+        user_input = state.get("user_input") or (
+            state["dialogue_history"][-1]["content"] if state.get("dialogue_history") else ""
+        )
+
+        # Immediate exit bypass: if user typed exit / quit / q
+        if state.get("is_solved") or user_input.lower().strip() in ["exit", "quit", "q"]:
+            EventBus.emit_evaluator_verdict("SOLVED")
+            return {
+                "eval_status": "surrendered",
+                "is_solved": True,
+            }
+
         prompt = EvaluationPrompt.evaluation_prompt(
-                error_type=state["error_type"],
-                code_snippet=state["code_snippet"],
-                root_cause=state["root_cause"],
-                user_input=state.get("user_input") or state["dialogue_history"][-1]["content"]
+            error_type=state["error_type"],
+            code_snippet=state["code_snippet"],
+            root_cause=state["root_cause"],
+            user_input=user_input,
         )
-        
+
         response = LLMFactory.get_llm().invoke(prompt)
         verdict = response.content.strip().upper()
 
@@ -30,7 +42,7 @@ class EvaluationNode:
             status = "struggling"
             is_solved = False
 
-        SocraticUI.display_evaluator_verdict(verdict_key)
+        EventBus.emit_evaluator_verdict(verdict_key)
 
         return {
             "eval_status": status,

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/agent/nodes/human_input_node.py

@@ -1,18 +1,21 @@
 from src.agent.state.state import SocraticAgentState
-from ui.views import SocraticUI
-from ui.console import console
+from src.events import EventBus
 
 
 class HumanInputNode:
     @staticmethod
     def human_input_node(state: SocraticAgentState) -> dict:
-        user_input = SocraticUI.prompt_user_input()
-
-        if user_input.lower().strip() in ["exit", "quit", "q"]:
-            console.print("\n[bold yellow]👋 Exiting Socratic debugging session. Keep coding![/bold yellow]\n")
-            return {"is_solved": True}
+        user_input = EventBus.request_user_input()
 
         history = list(state.get("dialogue_history", []))
         history.append({"role": "student", "content": user_input})
-        
+
+        if user_input.lower().strip() in ["exit", "quit", "q"]:
+            return {
+                "user_input": user_input,
+                "dialogue_history": history,
+                "is_solved": True,
+                "eval_status": "surrendered",
+            }
+
         return {"user_input": user_input, "dialogue_history": history}

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/agent/nodes/questioner_node.py

@@ -3,7 +3,7 @@ from src.agent.state.state import SocraticAgentState
 from src.agent.llm.factory import LLMFactory
 from src.utils.read_yaml import ReadYaml
 
-from ui.views import SocraticUI
+from src.events import EventBus
 
 config = ReadYaml.read_yaml()
 
@@ -33,7 +33,7 @@ class QuestionerNode:
 
         response = LLMFactory.get_llm().invoke(prompt)
 
-        SocraticUI.display_mentor_message(
+        EventBus.emit_mentor_message(
             content=response.content,
             hint_level=current_hint,
         )

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/agent/nodes/solution_node.py

@@ -2,8 +2,7 @@ from src.agent.prompts.solution_prompt import SolutionPrompt
 from src.agent.state.state import SocraticAgentState
 from src.agent.llm.factory import LLMFactory
 from src.utils.read_yaml import ReadYaml
-
-from ui.views import SocraticUI
+from src.events import EventBus
 
 config = ReadYaml.read_yaml()
 
@@ -25,7 +24,7 @@ class SolutionNode:
 
         response = LLMFactory.get_llm().invoke(prompt)
 
-        SocraticUI.display_solution(response.content)
+        EventBus.emit_solution(response.content)
 
         history = list(state.get("dialogue_history", []))
         history.append({"role": "mentor", "content": response.content})

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/agent/runner.py

@@ -2,7 +2,7 @@ from src.extractor import extract_crash_context
 from src.agent.graph.graph import SocraticGraph
 
 def run_socratic_agent(exception_type, exception_value, exception_traceback):
-    context = extract_crash_context(exception_traceback)
+    context = extract_crash_context(exception_traceback, exception_value)
 
     initial_state = {
         "file_path": context["file_path"],

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/src/cli.py

@@ -1,31 +1,29 @@
 import sys
-import os
 from pathlib import Path
 
-# Add project root to sys.path so modules and UI resolve everywhere
+# Add project root to sys.path so modules resolve everywhere
 project_root = str(Path(__file__).resolve().parent.parent)
 if project_root not in sys.path:
     sys.path.insert(0, project_root)
 
 from src.hook import install
-from ui.console import console
 
 
 def print_usage():
-    console.print("""
-[bold cyan]🧠 Socratic Debug — Autonomous Pedagogical Debugger[/bold cyan]
+    print("""
+🧠 Socratic Debug — Autonomous Pedagogical Debugger
 
-[bold yellow]Usage:[/bold yellow]
-  [green]socratic run <script.py>[/green]   Run a Python file under Socratic supervision
-  [green]socratic init[/green]              Create a default .socratic.yaml config file
-  [green]socratic --help[/green]            Show this help message
+Usage:
+  socratic run <script.py>   Run a Python file under Socratic supervision
+  socratic init              Create a default .socratic.yaml config file
+  socratic --help            Show this help message
 """)
 
 
 def run_target_script(script_path: str, script_args: list):
     resolved_path = Path(script_path).resolve()
     if not resolved_path.exists():
-        console.print(f"[bold red]Error:[/bold red] File not found: [yellow]{resolved_path}[/yellow]")
+        print(f"Error: File not found: {resolved_path}")
         sys.exit(1)
 
     # Automatically install Socratic hook before user code executes
@@ -50,7 +48,7 @@ def run_target_script(script_path: str, script_args: list):
     except SystemExit:
         raise
     except Exception:
-        # sys.excepthook will catch this cleanly and launch Socratic GUI!
+        # sys.excepthook will catch this cleanly and launch Socratic!
         sys.excepthook(*sys.exc_info())
 
 
@@ -68,19 +66,13 @@ def main():
     elif command == "init":
         from src.config_creator import create_config
         create_config()
-        console.print("[bold green]✔[/bold green] Created [cyan].socratic.yaml[/cyan] with default settings.")
+        print("✔ Created .socratic.yaml with default settings.")
         sys.exit(0)
 
-    elif command == "session":
-        # Internal command executed inside the dedicated popup window
-        target_file = sys.argv[2]
-        extra_args = sys.argv[3:]
-        run_target_script(target_file, extra_args, force_in_process=True)
-
     elif command == "run":
         if len(sys.argv) < 3:
-            console.print("[bold red]Error:[/bold red] Missing script file to run.")
-            console.print("Example: [green]socratic run app.py[/green]")
+            print("Error: Missing script file to run.")
+            print("Example: socratic run app.py")
             sys.exit(1)
 
         target_file = sys.argv[2]

socratic_debug-0.0.4/src/events.py

@@ -0,0 +1,67 @@
+from typing import Callable, Optional, Any, Dict
+
+
+class EventBus:
+    # Callbacks registered by external UI layers (PyQt6, Webview, CLI, etc.)
+    _on_mentor_message: Optional[Callable[[str, int], None]] = None
+    _on_user_input_requested: Optional[Callable[[], str]] = None
+    _on_evaluator_verdict: Optional[Callable[[str], None]] = None
+    _on_solution: Optional[Callable[[str], None]] = None
+    _on_crash: Optional[Callable[[Dict[str, Any], Any, Any, Any], None]] = None
+
+    @classmethod
+    def register_handlers(
+        cls,
+        on_mentor_message: Optional[Callable[[str, int], None]] = None,
+        on_user_input_requested: Optional[Callable[[], str]] = None,
+        on_evaluator_verdict: Optional[Callable[[str], None]] = None,
+        on_solution: Optional[Callable[[str], None]] = None,
+        on_crash: Optional[Callable[[Dict[str, Any], Any, Any, Any], None]] = None,
+    ):
+        """Registers presentation callbacks into the Core event bus."""
+        if on_mentor_message:
+            cls._on_mentor_message = on_mentor_message
+        if on_user_input_requested:
+            cls._on_user_input_requested = on_user_input_requested
+        if on_evaluator_verdict:
+            cls._on_evaluator_verdict = on_evaluator_verdict
+        if on_solution:
+            cls._on_solution = on_solution
+        if on_crash:
+            cls._on_crash = on_crash
+
+    @classmethod
+    def emit_mentor_message(cls, content: str, hint_level: int = 1):
+        if cls._on_mentor_message:
+            cls._on_mentor_message(content, hint_level)
+        else:
+            # Fallback pure standard output
+            print(f"\n[Socratic Mentor (Level {hint_level})]: {content}\n")
+
+    @classmethod
+    def request_user_input(cls) -> str:
+        if cls._on_user_input_requested:
+            return cls._on_user_input_requested()
+        return input("❯❯ Your Response: ").strip()
+
+    @classmethod
+    def emit_evaluator_verdict(cls, verdict: str):
+        if cls._on_evaluator_verdict:
+            cls._on_evaluator_verdict(verdict)
+        else:
+            print(f"  🔍 Verdict: {verdict}")
+
+    @classmethod
+    def emit_solution(cls, solution_content: str):
+        if cls._on_solution:
+            cls._on_solution(solution_content)
+        else:
+            print(f"\n🏆 Wrap-Up:\n{solution_content}\n")
+
+    @classmethod
+    def emit_crash(cls, context: Dict[str, Any], exc_type: Any, exc_val: Any, exc_tb: Any):
+        if cls._on_crash:
+            cls._on_crash(context, exc_type, exc_val, exc_tb)
+        else:
+            print(f"\n💥 {exc_type.__name__}: {exc_val}")
+            print(f"📍 {context.get('file_path')}:{context.get('line_number')}\n")

socratic_debug-0.0.4/src/extractor.py

@@ -0,0 +1,72 @@
+import traceback
+from pathlib import Path
+
+
+def extract_crash_context(exception_traceback, exception_value=None) -> dict:
+    # 1. Handle SyntaxError / IndentationError where location is on exception_value
+    if isinstance(exception_value, SyntaxError):
+        file_path = exception_value.filename or "unknown"
+        line_number = exception_value.lineno or 1
+        line_content = (exception_value.text or "").strip()
+        snippet = get_code_snippet(file_path, line_number)
+
+        return {
+            "file_path": file_path,
+            "line_number": line_number,
+            "function_name": "<module>",
+            "line_content": line_content,
+            "code_snippet": snippet,
+        }
+
+    # 2. Handle Runtime Errors via Traceback Frames
+    frames = traceback.extract_tb(exception_traceback) if exception_traceback else []
+
+    # Find the deepest frame that belongs to user code (ignore socratic internal frames)
+    socratic_src_dir = str(Path(__file__).resolve().parent)
+    chosen_frame = None
+
+    for frame in reversed(frames):
+        if not frame.filename.startswith(socratic_src_dir):
+            chosen_frame = frame
+            break
+
+    if chosen_frame is None and frames:
+        chosen_frame = frames[-1]
+
+    if chosen_frame:
+        snippet = get_code_snippet(chosen_frame.filename, chosen_frame.lineno)
+        return {
+            "file_path": chosen_frame.filename,
+            "line_number": chosen_frame.lineno,
+            "function_name": chosen_frame.name,
+            "line_content": chosen_frame.line or "",
+            "code_snippet": snippet,
+        }
+
+    return {
+        "file_path": "unknown",
+        "line_number": 1,
+        "function_name": "<unknown>",
+        "line_content": "",
+        "code_snippet": "",
+    }
+
+
+def get_code_snippet(file_path: str, line_number: int, context_lines: int = 5) -> str:
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        start_lines = max(1, line_number - context_lines)
+        end_lines = min(len(lines), line_number + context_lines)
+
+        snippet_lines = []
+        for i in range(start_lines, end_lines + 1):
+            prefix = ">" if i == line_number else " "
+            line_text = lines[i - 1]
+            snippet_lines.append(f"{prefix} {i:3d} | {line_text}")
+
+        return "".join(snippet_lines)
+
+    except Exception as e:
+        return f"Error getting code snippet: {e}"

socratic_debug-0.0.4/src/hook.py

@@ -0,0 +1,21 @@
+import sys
+from src.extractor import extract_crash_context
+from src.config_creator import create_config
+from src.events import EventBus
+
+
+def socratic_excepthook(exception_type, exception_value, exception_traceback):
+    """Intercepts uncaught exceptions and delegates to the decoupled EventBus."""
+    context = extract_crash_context(exception_traceback, exception_value)
+    EventBus.emit_crash(
+        context=context,
+        exc_type=exception_type,
+        exc_val=exception_value,
+        exc_tb=exception_traceback,
+    )
+
+
+def install():
+    """Installs Socratic as the global system exception hook."""
+    create_config()
+    sys.excepthook = socratic_excepthook

socratic_debug-0.0.4/src/watcher.py

@@ -0,0 +1,88 @@
+import os
+import time
+import ast
+import subprocess
+import sys
+import threading
+
+
+class FileMonitor(threading.Thread):
+    def __init__(
+        self,
+        file_path: str,
+        target_error: str,
+        on_solved_callback,
+        on_failed_callback,
+    ):
+        super().__init__(daemon=True)
+        self.file_path = file_path
+        self.target_error = target_error.strip()
+        self.on_solved_callback = on_solved_callback
+        self.on_failed_callback = on_failed_callback
+        self.last_mtime = os.path.getmtime(file_path)
+        self.running = True
+        self._last_reported_err = ""
+
+    def run(self):
+        while self.running:
+            time.sleep(0.5)
+
+            try:
+                current_mtime = os.path.getmtime(self.file_path)
+            except OSError:
+                continue
+
+            if current_mtime != self.last_mtime:
+                self.last_mtime = current_mtime
+                time.sleep(1.8)
+
+                # Skip if user is actively typing and mtime kept updating
+                try:
+                    if os.path.getmtime(self.file_path) != current_mtime:
+                        continue
+                except OSError:
+                    continue
+
+                # Quick AST syntax validation (ignore incomplete statements while typing)
+                try:
+                    with open(self.file_path, "r", encoding="utf-8") as file:
+                        ast.parse(file.read())
+                except (SyntaxError, OSError):
+                    continue
+
+                # Execute script in silent background subprocess
+                try:
+                    res = subprocess.run(
+                        [sys.executable, self.file_path],
+                        capture_output=True,
+                        text=True,
+                        timeout=7,
+                    )
+
+                    # Scenario A: Clean execution with zero errors
+                    if res.returncode == 0:
+                        self.on_solved_callback()
+                        self.running = False
+                        break
+
+                    # If the script has a SyntaxError, the user is still writing or broke the syntax
+                    if "SyntaxError" in res.stderr:
+                        continue
+
+                    # Scenario B: Target error is resolved and code progresses past it
+                    if self.target_error and self.target_error not in res.stderr:
+                        # Ensure it's not a generic failure before the target error
+                        self.on_solved_callback()
+                        self.running = False
+                        break
+
+                    # Scenario C: Target error still occurs
+                    current_err = res.stderr.strip()
+                    if current_err != self._last_reported_err:
+                        self._last_reported_err = current_err
+                        self.on_failed_callback(res.stderr)
+
+                except subprocess.TimeoutExpired:
+                    continue
+                except Exception:
+                    continue

socratic_debug-0.0.2/test/test_hock.py → socratic_debug-0.0.4/test/test_hook.py

@@ -17,7 +17,10 @@ print("*" * 20)
 number_1 = 10
 number_2 = 0
 
-print(number_1 / number_2)
+if number_2 == 0:
+    print("sorry we can't do it")
+else:
+    print(number_1 / number_2)
 
 # test a logic error
 print("make a logic error in the average function")

socratic_debug-0.0.4/ui/adapter.py

@@ -0,0 +1,23 @@
+from src.events import EventBus
+from src.agent.runner import run_socratic_agent
+from ui.views import SocraticUI
+
+
+def register_ui_adapter():
+    """Binds the SocraticUI presentation layer to the Core EventBus.
+
+    This ensures complete decoupling: Core never imports UI.
+    """
+    EventBus.register_handlers(
+        on_mentor_message=SocraticUI.display_mentor_message,
+        on_user_input_requested=SocraticUI.prompt_user_input,
+        on_evaluator_verdict=SocraticUI.display_evaluator_verdict,
+        on_solution=SocraticUI.display_solution,
+        on_crash=lambda ctx, etype, evalue, tb: SocraticUI.launch(
+            context=ctx,
+            exception_type=etype,
+            exception_value=evalue,
+            exception_traceback=tb,
+            agent_runner_func=run_socratic_agent,
+        ),
+    )

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/ui/app.py

@@ -17,6 +17,8 @@ try:
         user_input_requested = pyqtSignal()
         solution_received = pyqtSignal(str)
         evaluator_verdict_received = pyqtSignal(str)
+        live_solution_detected = pyqtSignal()
+        live_error_detected = pyqtSignal(str)
 
     bridge = UIBridge()
 
@@ -38,6 +40,8 @@ except (ImportError, OSError):
         user_input_requested = MockSignal()
         solution_received = MockSignal()
         evaluator_verdict_received = MockSignal()
+        live_solution_detected = MockSignal()
+        live_error_detected = MockSignal()
 
     bridge = DummyBridge()
 
@@ -158,6 +162,8 @@ class SocraticWindow(QMainWindow):
 
         self.send_button = QPushButton(self.translations["send_btn"], self)
         self.send_button.setObjectName("sendButton")
+        if Qt is not None:
+            self.send_button.setCursor(Qt.CursorShape.PointingHandCursor)
         self.send_button.clicked.connect(self._on_send_clicked)
         self.send_button.setEnabled(False)
 
@@ -170,6 +176,43 @@ class SocraticWindow(QMainWindow):
         bridge.user_input_requested.connect(self._enable_user_input)
         bridge.solution_received.connect(self._append_solution)
         bridge.evaluator_verdict_received.connect(self._append_verdict)
+        bridge.live_solution_detected.connect(self._on_live_solution_detected)
+        bridge.live_error_detected.connect(self._on_live_error_detected)
+
+    def _on_live_solution_detected(self):
+        self.status_badge.setText(self.translations["status_solved"])
+        self.status_badge.setStyleSheet("color: #ffffff; background-color: #238636;")
+
+        celebration_html = (
+            f"<div style='background-color: #162a1c; border: 1px solid #238636; "
+            f"border-radius: 8px; padding: 12px; margin: 8px 0; color: #3fb950; font-size: 14px;'>"
+            f"<b>{self.translations['live_solved_msg']}</b></div>"
+        )
+        self.chat_area.append(celebration_html)
+        self._scroll_to_bottom()
+
+        # Switch send button to Close button
+        self.input_field.setEnabled(False)
+        self.send_button.setEnabled(True)
+        self.send_button.setText(self.translations["close_btn"])
+        self.send_button.setStyleSheet("background-color: #238636; color: #ffffff;")
+        try:
+            self.send_button.clicked.disconnect()
+        except TypeError:
+            pass
+        self.send_button.clicked.connect(self.close)
+
+        # Release background worker thread if waiting for user input
+        submit_gui_user_input("q")
+
+    def _on_live_error_detected(self, error_trace: str):
+        retry_html = (
+            f"<div style='background-color: #2b1d20; border: 1px solid #da3633; "
+            f"border-radius: 8px; padding: 10px; margin: 8px 0; color: #ff7b72; font-size: 13px;'>"
+            f"<b>{self.translations['live_retry_msg']}</b></div>"
+        )
+        self.chat_area.append(retry_html)
+        self._scroll_to_bottom()
 
     def _append_mentor_message(self, content: str, hint_level: int):
         html_msg = ChatTemplates.mentor_bubble(
@@ -222,6 +265,17 @@ class SocraticWindow(QMainWindow):
         self.chat_area.append(sol_html)
         self._scroll_to_bottom()
 
+        # Switch send button to Close Session button
+        self.input_field.setEnabled(False)
+        self.send_button.setEnabled(True)
+        self.send_button.setText(self.translations["close_btn"])
+        self.send_button.setStyleSheet("background-color: #238636; color: #ffffff;")
+        try:
+            self.send_button.clicked.disconnect()
+        except TypeError:
+            pass
+        self.send_button.clicked.connect(self.close)
+
     def _scroll_to_bottom(self):
         cursor = self.chat_area.textCursor()
         cursor.movePosition(QTextCursor.MoveOperation.End)

{socratic_debug-0.0.2 → socratic_debug-0.0.4}/ui/translations.py

@@ -13,6 +13,9 @@ TRANSLATIONS = {
         "hint_level": "مستوى التلميح",
         "user_tag": "إجابتك",
         "wrapup_title": "🏆 الحل النهائي وأفضل الممارسات البرمجية",
+        "live_solved_msg": "🎉 عاش يا بطل! لقطت إنك عدلت الكود واشتغل بنجاح والمشكلة اتحلت خلاص!",
+        "live_retry_msg": "👀 لقطت تعديلك على الكود، بس لسه فيه خطأ بيظهر. راجع التعديل وفكر في النقطة اللي اتكلمنا فيها!",
+        "close_btn": "إنهاء الجلسة",
     },
     "english": {
         "app_title": "🧠 Socratic Debug — Autonomous Mentor",
@@ -27,5 +30,8 @@ TRANSLATIONS = {
         "hint_level": "Hint Level",
         "user_tag": "Your Response",
         "wrapup_title": "🏆 Socratic Wrap-Up & Defensive Best Practice",
+        "live_solved_msg": "🎉 Awesome! Detected your code change and the script executed successfully with no errors!",
+        "live_retry_msg": "👀 Detected your code change, but an error is still occurring. Review the change and keep thinking!",
+        "close_btn": "Close Session",
     }
 }

socratic_debug-0.0.4/ui/views.py

@@ -0,0 +1,115 @@
+import os
+import sys
+import threading
+from ui.app import bridge, wait_for_gui_user_input
+from ui.console import console
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+
+class SocraticUI:
+    """Unified UI layer: seamlessly routes to PyQt6 Desktop Terminal or CLI Fallback."""
+
+    @staticmethod
+    def is_gui_active() -> bool:
+        return os.environ.get("SOCRATIC_GUI_ACTIVE") == "1"
+
+    @staticmethod
+    def launch(context: dict, exception_type, exception_value, exception_traceback, agent_runner_func):
+        """Encapsulates GUI initialization, file monitor, background agent thread, or headless fallback."""
+        has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY") or sys.platform == "win32")
+
+        if has_display:
+            try:
+                from PyQt6.QtWidgets import QApplication
+                from ui.app import SocraticWindow
+
+                os.environ["SOCRATIC_GUI_ACTIVE"] = "1"
+
+                app = QApplication.instance()
+                if app is None:
+                    app = QApplication(sys.argv)
+
+                window = SocraticWindow(
+                    error_type=exception_type.__name__,
+                    error_message=str(exception_value),
+                    file_path=context["file_path"],
+                    line_number=context["line_number"],
+                    line_content=context["line_content"],
+                )
+                window.show()
+
+                # Launch LangGraph agent in background worker thread
+                agent_thread = threading.Thread(
+                    target=agent_runner_func,
+                    args=(exception_type, exception_value, exception_traceback),
+                    daemon=True,
+                )
+                agent_thread.start()
+
+                # Launch real-time file monitor if target file exists
+                if os.path.exists(context["file_path"]):
+                    from src.watcher import FileMonitor
+                    file_monitor = FileMonitor(
+                        file_path=context["file_path"],
+                        target_error=exception_type.__name__,
+                        on_solved_callback=lambda: bridge.live_solution_detected.emit(),
+                        on_failed_callback=lambda err: bridge.live_error_detected.emit(err),
+                    )
+                    file_monitor.start()
+
+                app.exec()
+                return
+            except Exception:
+                # Fallback gracefully to terminal mode if GUI setup fails
+                pass
+
+        # Headless / Terminal Fallback Mode
+        os.environ["SOCRATIC_GUI_ACTIVE"] = "0"
+        SocraticUI.display_crash_banner(
+            error_type=exception_type.__name__,
+            error_message=str(exception_value),
+            file_path=context["file_path"],
+            line_number=context["line_number"],
+            line_content=context["line_content"],
+        )
+        agent_runner_func(exception_type, exception_value, exception_traceback)
+
+    @staticmethod
+    def display_crash_banner(error_type: str, error_message: str, file_path: str, line_number: int, line_content: str):
+        # In CLI fallback mode, print Rich banner
+        if not SocraticUI.is_gui_active():
+            console.print(f"\n[bold red]💥 {error_type}: {error_message}[/bold red]")
+            console.print(f"[dim]📍 {file_path}:{line_number}[/dim]\n")
+
+    @staticmethod
+    def display_mentor_message(content: str, hint_level: int = 1):
+        if SocraticUI.is_gui_active():
+            bridge.mentor_message_received.emit(content, hint_level)
+        else:
+            md = Markdown(content)
+            panel = Panel(md, title=f"Socratic Mentor (Level {hint_level}/3)", border_style="cyan")
+            console.print(panel)
+
+    @staticmethod
+    def prompt_user_input() -> str:
+        if SocraticUI.is_gui_active():
+            return wait_for_gui_user_input()
+        else:
+            return console.input("[bold yellow]❯❯ Your Response: [/bold yellow]").strip()
+
+    @staticmethod
+    def display_evaluator_verdict(verdict: str):
+        if SocraticUI.is_gui_active():
+            bridge.evaluator_verdict_received.emit(verdict)
+        else:
+            console.print(f"  [bold yellow]🔍 {verdict}[/bold yellow]\n")
+
+    @staticmethod
+    def display_solution(solution_content: str):
+        if SocraticUI.is_gui_active():
+            bridge.solution_received.emit(solution_content)
+        else:
+            md = Markdown(solution_content)
+            panel = Panel(md, title="🏆 Socratic Wrap-Up", border_style="green")
+            console.print(panel)

socratic_debug-0.0.2/socratic.py

@@ -1,8 +0,0 @@
-"""
-Socratic Debug — Autonomous pedagogical debugging mentor.
-"""
-
-from src.hook import install
-from src.agent.runner import run_socratic_agent
-
-__all__ = ["install", "run_socratic_agent"]

socratic_debug-0.0.2/socratic_debug.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-socratic = src.cli:main

socratic_debug-0.0.2/src/extractor.py

@@ -1,34 +0,0 @@
-import traceback
-
-def extract_crash_context(exception_traceback) -> dict:
-    frames = traceback.extract_tb(exception_traceback)
-    last_frame = frames[-1]
-
-    snippet = get_code_snippet(last_frame.filename, last_frame.lineno)
-
-    return {
-        "file_path": last_frame.filename,
-        "line_number": last_frame.lineno,
-        "function_name": last_frame.name,
-        "line_content": last_frame.line,
-        "code_snippet": snippet
-    }
-
-def get_code_snippet(file_path: str, line_number: int, context_lines: int = 5) -> str:
-    try:
-        with open(file_path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-
-            start_lines = max(1, line_number - context_lines)
-            end_lines = min(len(lines), line_number + context_lines)
-
-            snippet_lines = []
-            for i in range(start_lines, end_lines + 1):
-                prefix = ">" if i == line_number else " "
-                line_text = lines[i - 1]
-                snippet_lines.append(f"{prefix} {i:3d} | {line_text}")
-
-            return "".join(snippet_lines)
-
-    except Exception as e:
-        return f"Error getting code snippet: {e}"

socratic_debug-0.0.2/src/hook.py

@@ -1,67 +0,0 @@
-import sys
-import os
-import threading
-from src.extractor import extract_crash_context
-from src.config_creator import create_config
-from src.agent.runner import run_socratic_agent
-from ui.views import SocraticUI
-
-
-def socratic_excepthook(exception_type, exception_value, exception_traceback):
-    """Intercepts uncaught exceptions and launches the Socratic GUI Terminal window."""
-    context = extract_crash_context(exception_traceback)
-
-    # Check if graphical desktop display is available
-    has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY") or sys.platform == "win32")
-
-    if has_display:
-        try:
-            from PyQt6.QtWidgets import QApplication
-            from ui.app import SocraticWindow
-
-            os.environ["SOCRATIC_GUI_ACTIVE"] = "1"
-
-            app = QApplication.instance()
-            if app is None:
-                app = QApplication(sys.argv)
-
-            # Create and display the centered Socratic Terminal window
-            window = SocraticWindow(
-                error_type=exception_type.__name__,
-                error_message=str(exception_value),
-                file_path=context["file_path"],
-                line_number=context["line_number"],
-                line_content=context["line_content"],
-            )
-            window.show()
-
-            # Run LangGraph State Machine in background worker thread
-            agent_thread = threading.Thread(
-                target=run_socratic_agent,
-                args=(exception_type, exception_value, exception_traceback),
-                daemon=True,
-            )
-            agent_thread.start()
-
-            # Run Qt GUI event loop
-            app.exec()
-            return
-        except Exception as e:
-            # Fallback to terminal mode if GUI setup fails
-            pass
-
-    # Headless / Terminal Fallback Mode
-    os.environ["SOCRATIC_GUI_ACTIVE"] = "0"
-    SocraticUI.display_crash_banner(
-        error_type=exception_type.__name__,
-        error_message=str(exception_value),
-        file_path=context["file_path"],
-        line_number=context["line_number"],
-        line_content=context["line_content"],
-    )
-    run_socratic_agent(exception_type, exception_value, exception_traceback)
-
-# use the hook 
-def install():
-    create_config()
-    sys.excepthook = socratic_excepthook

socratic_debug-0.0.2/ui/views.py

@@ -1,52 +0,0 @@
-import os
-from ui.app import bridge, wait_for_gui_user_input
-from ui.console import console
-from rich.panel import Panel
-from rich.markdown import Markdown
-
-
-class SocraticUI:
-    """Unified UI layer: seamlessly routes to PyQt6 Desktop Terminal or CLI Fallback."""
-
-    @staticmethod
-    def is_gui_active() -> bool:
-        return os.environ.get("SOCRATIC_GUI_ACTIVE") == "1"
-
-    @staticmethod
-    def display_crash_banner(error_type: str, error_message: str, file_path: str, line_number: int, line_content: str):
-        # In CLI fallback mode, print Rich banner
-        if not SocraticUI.is_gui_active():
-            console.print(f"\n[bold red]💥 {error_type}: {error_message}[/bold red]")
-            console.print(f"[dim]📍 {file_path}:{line_number}[/dim]\n")
-
-    @staticmethod
-    def display_mentor_message(content: str, hint_level: int = 1):
-        if SocraticUI.is_gui_active():
-            bridge.mentor_message_received.emit(content, hint_level)
-        else:
-            md = Markdown(content)
-            panel = Panel(md, title=f"Socratic Mentor (Level {hint_level}/3)", border_style="cyan")
-            console.print(panel)
-
-    @staticmethod
-    def prompt_user_input() -> str:
-        if SocraticUI.is_gui_active():
-            return wait_for_gui_user_input()
-        else:
-            return console.input("[bold yellow]❯❯ Your Response: [/bold yellow]").strip()
-
-    @staticmethod
-    def display_evaluator_verdict(verdict: str):
-        if SocraticUI.is_gui_active():
-            bridge.evaluator_verdict_received.emit(verdict)
-        else:
-            console.print(f"  [bold yellow]🔍 {verdict}[/bold yellow]\n")
-
-    @staticmethod
-    def display_solution(solution_content: str):
-        if SocraticUI.is_gui_active():
-            bridge.solution_received.emit(solution_content)
-        else:
-            md = Markdown(solution_content)
-            panel = Panel(md, title="🏆 Socratic Wrap-Up", border_style="green")
-            console.print(panel)