fishertools 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

fishertools/learn/repl/command_parser.py

@@ -0,0 +1,165 @@
+"""
+Command parser for the Knowledge Engine REPL.
+
+This module handles parsing user input to identify commands, topic names, and edit mode input.
+"""
+
+import shlex
+from typing import Tuple, List
+
+
+class CommandParser:
+    """
+    Parses user input to identify command type and extract arguments.
+    
+    Supports three input types:
+    - Commands: Start with "/" (e.g., "/help", "/search python")
+    - Topic names: Regular text matching a topic in the Knowledge Engine
+    - Edit mode input: Code or commands while in edit mode
+    """
+    
+    # Commands that are recognized by the REPL
+    VALID_COMMANDS = {
+        "help", "list", "search", "random", "categories", "category",
+        "path", "related", "progress", "stats", "hint", "tip", "tips",
+        "run", "modify", "exit_edit", "history", "clear_history", "session",
+        "reset_progress", "commands", "about", "tutorial", "next", "prev",
+        "goto", "exit", "quit"
+    }
+    
+    @staticmethod
+    def parse(input_str: str) -> Tuple[str, List[str]]:
+        """
+        Parse user input into command type and arguments.
+        
+        Args:
+            input_str: The user input string
+        
+        Returns:
+            Tuple of (command_type, arguments) where:
+            - command_type: 'command', 'topic', or 'edit'
+            - arguments: List of argument strings
+        
+        Raises:
+            ValueError: If input cannot be parsed
+        
+        Example:
+            >>> parser = CommandParser()
+            >>> cmd_type, args = parser.parse("/help")
+            >>> cmd_type
+            'command'
+            >>> args
+            ['help']
+            
+            >>> cmd_type, args = parser.parse("/search python")
+            >>> args
+            ['search', 'python']
+            
+            >>> cmd_type, args = parser.parse("Lists")
+            >>> cmd_type
+            'topic'
+            >>> args
+            ['Lists']
+        """
+        if not input_str or not input_str.strip():
+            raise ValueError("Input cannot be empty")
+        
+        input_str = input_str.strip()
+        
+        # Check if it's a command (starts with /)
+        if input_str.startswith("/"):
+            return CommandParser._parse_command(input_str)
+        
+        # Otherwise it's a topic name or edit mode input
+        return "topic", [input_str]
+    
+    @staticmethod
+    def _parse_command(input_str: str) -> Tuple[str, List[str]]:
+        """
+        Parse a command string (starts with /).
+        
+        Args:
+            input_str: Command string starting with /
+        
+        Returns:
+            Tuple of ('command', [command_name, arg1, arg2, ...])
+        
+        Raises:
+            ValueError: If command format is invalid
+        """
+        # Remove leading /
+        command_str = input_str[1:].strip()
+        
+        if not command_str:
+            raise ValueError("Command cannot be empty")
+        
+        # Use shlex to handle quoted arguments
+        try:
+            parts = shlex.split(command_str)
+        except ValueError as e:
+            raise ValueError(f"Invalid command format: {e}")
+        
+        if not parts:
+            raise ValueError("Command cannot be empty")
+        
+        command_name = parts[0].lower()
+        args = parts[1:] if len(parts) > 1 else []
+        
+        # Validate command name
+        if command_name not in CommandParser.VALID_COMMANDS:
+            raise ValueError(f"Unknown command: {command_name}")
+        
+        return "command", [command_name] + args
+    
+    @staticmethod
+    def normalize_topic_name(name: str) -> str:
+        """
+        Normalize a topic name for comparison.
+        
+        Args:
+            name: The topic name to normalize
+        
+        Returns:
+            Normalized topic name (preserves case but strips whitespace)
+        """
+        return name.strip()
+    
+    @staticmethod
+    def is_command(input_str: str) -> bool:
+        """
+        Check if input is a command.
+        
+        Args:
+            input_str: The input string to check
+        
+        Returns:
+            True if input starts with /
+        """
+        return input_str.strip().startswith("/")
+    
+    @staticmethod
+    def extract_command_name(input_str: str) -> str:
+        """
+        Extract just the command name from a command string.
+        
+        Args:
+            input_str: Command string starting with /
+        
+        Returns:
+            The command name (lowercase)
+        
+        Raises:
+            ValueError: If input is not a valid command
+        """
+        if not input_str.startswith("/"):
+            raise ValueError("Not a command")
+        
+        command_str = input_str[1:].strip()
+        if not command_str:
+            raise ValueError("Command cannot be empty")
+        
+        try:
+            parts = shlex.split(command_str)
+            return parts[0].lower()
+        except ValueError as e:
+            raise ValueError(f"Invalid command format: {e}")

fishertools/learn/repl/engine.py

@@ -0,0 +1,479 @@
+"""
+Main REPL Engine for the Knowledge Engine Interactive REPL.
+
+This module provides the main loop and orchestration for the REPL system.
+"""
+
+from typing import Optional, List, Tuple
+from fishertools.learn.knowledge_engine import KnowledgeEngine
+from fishertools.learn.repl.command_parser import CommandParser
+from fishertools.learn.repl.command_handler import CommandHandler
+from fishertools.learn.repl.code_sandbox import CodeSandbox
+from fishertools.learn.repl.session_manager import SessionManager
+
+
+class REPLEngine:
+    """
+    Main REPL engine that orchestrates user interaction.
+    
+    Manages:
+    - User input parsing
+    - Command execution
+    - Topic display
+    - Session state
+    - Code execution
+    
+    Example:
+        >>> engine = REPLEngine()
+        >>> engine.start()
+    """
+    
+    WELCOME_MESSAGE = """
+╔════════════════════════════════════════════════════════════════╗
+║     Welcome to the Knowledge Engine Interactive REPL! 🎓      ║
+║                                                                ║
+║  Learn Python concepts interactively with examples and tips.  ║
+║  Type /help to see available commands.                        ║
+║  Type /exit or /quit to exit.                                 ║
+╚════════════════════════════════════════════════════════════════╝
+"""
+    
+    def __init__(self, engine: Optional[KnowledgeEngine] = None, 
+                 session_manager: Optional[SessionManager] = None):
+        """
+        Initialize the REPL engine.
+        
+        Args:
+            engine: Optional Knowledge Engine instance (creates new if not provided)
+            session_manager: Optional SessionManager instance (creates new if not provided)
+        """
+        self.engine = engine or KnowledgeEngine()
+        self.session_manager = session_manager or SessionManager()
+        self.command_handler = CommandHandler(self.engine, self.session_manager)
+        self.code_sandbox = CodeSandbox()
+        self.parser = CommandParser()
+        
+        self.current_topic: Optional[str] = None
+        self.in_edit_mode = False
+        self.edit_topic: Optional[str] = None
+        self.edit_example_num: Optional[int] = None
+        self.edit_code: str = ""
+        self.running = False
+    
+    def start(self) -> None:
+        """
+        Start the interactive REPL loop.
+        
+        Displays welcome message and enters main loop.
+        """
+        print(self.WELCOME_MESSAGE)
+        
+        # Load previous session if available
+        if self.session_manager.get_current_topic():
+            self.current_topic = self.session_manager.get_current_topic()
+            print(f"📚 Resuming previous session. Last topic: {self.current_topic}\n")
+        
+        self.running = True
+        
+        try:
+            while self.running:
+                self._prompt_and_process()
+        except KeyboardInterrupt:
+            print("\n\n👋 Goodbye! Your progress has been saved.")
+            self.session_manager.save_session()
+        except Exception as e:
+            print(f"\n❌ An unexpected error occurred: {e}")
+            print("Your progress has been saved.")
+            self.session_manager.save_session()
+    
+    def _prompt_and_process(self) -> None:
+        """
+        Prompt for user input and process it.
+        """
+        try:
+            if self.in_edit_mode:
+                prompt = f"[Edit {self.edit_topic} Example {self.edit_example_num}]> "
+            elif self.current_topic:
+                prompt = f"[{self.current_topic}]> "
+            else:
+                prompt = "> "
+            
+            user_input = input(prompt).strip()
+            
+            if not user_input:
+                return
+            
+            self._process_input(user_input)
+        
+        except EOFError:
+            self.running = False
+    
+    def _process_input(self, user_input: str) -> None:
+        """
+        Process user input.
+        
+        Args:
+            user_input: The user's input string
+        """
+        try:
+            cmd_type, args = self.parser.parse(user_input)
+        except ValueError as e:
+            print(f"❌ {e}")
+            return
+        
+        if cmd_type == "command":
+            self._handle_command(args)
+        elif cmd_type == "topic":
+            self._handle_topic_input(args[0])
+    
+    def _handle_command(self, args: List[str]) -> None:
+        """
+        Handle a command.
+        
+        Args:
+            args: Command and arguments [command_name, arg1, arg2, ...]
+        """
+        command = args[0]
+        command_args = args[1:] if len(args) > 1 else []
+        
+        # Exit commands
+        if command in ["exit", "quit"]:
+            print("👋 Goodbye! Your progress has been saved.")
+            self.session_manager.save_session()
+            self.running = False
+            return
+        
+        # Edit mode commands
+        if self.in_edit_mode:
+            if command == "exit_edit":
+                self._exit_edit_mode()
+            else:
+                print("❌ You are in edit mode. Type /exit_edit to exit.")
+            return
+        
+        # Topic browsing commands
+        if command == "list":
+            output = self.command_handler.handle_list()
+            print(output)
+        
+        elif command == "search":
+            keyword = " ".join(command_args) if command_args else ""
+            output = self.command_handler.handle_search(keyword)
+            print(output)
+        
+        elif command == "random":
+            output = self.command_handler.handle_random()
+            print(output)
+        
+        elif command == "categories":
+            output = self.command_handler.handle_categories()
+            print(output)
+        
+        elif command == "category":
+            category = " ".join(command_args) if command_args else ""
+            output = self.command_handler.handle_category(category)
+            print(output)
+        
+        elif command == "path":
+            output = self.command_handler.handle_path()
+            print(output)
+        
+        elif command == "related":
+            output = self.command_handler.handle_related(self.current_topic)
+            print(output)
+        
+        elif command == "next":
+            self._navigate_next()
+        
+        elif command == "prev":
+            self._navigate_prev()
+        
+        elif command == "goto":
+            topic = " ".join(command_args) if command_args else ""
+            self._navigate_to_topic(topic)
+        
+        # Code execution commands
+        elif command == "run":
+            if not self.current_topic:
+                print("❌ No current topic. View a topic first.")
+                return
+            
+            if not command_args:
+                print("❌ Please provide an example number.\nUsage: /run <number>")
+                return
+            
+            try:
+                example_num = int(command_args[0])
+                self._run_example(example_num)
+            except ValueError:
+                print("❌ Example number must be an integer.")
+        
+        elif command == "modify":
+            if not self.current_topic:
+                print("❌ No current topic. View a topic first.")
+                return
+            
+            if not command_args:
+                print("❌ Please provide an example number.\nUsage: /modify <number>")
+                return
+            
+            try:
+                example_num = int(command_args[0])
+                self._enter_edit_mode(example_num)
+            except ValueError:
+                print("❌ Example number must be an integer.")
+        
+        # Progress commands
+        elif command == "progress":
+            output = self.command_handler.handle_progress()
+            print(output)
+        
+        elif command == "stats":
+            output = self.command_handler.handle_stats()
+            print(output)
+        
+        elif command == "reset_progress":
+            response = input("⚠️  Are you sure you want to reset all progress? (yes/no): ").strip().lower()
+            if response == "yes":
+                self.session_manager.reset_progress()
+                print("✅ Progress reset.")
+            else:
+                print("❌ Reset cancelled.")
+        
+        # Session commands
+        elif command == "history":
+            history = self.session_manager.get_session_history()
+            if not history:
+                print("📋 Session history is empty.")
+            else:
+                print("📋 Session History:")
+                for i, topic in enumerate(history, 1):
+                    print(f"  {i}. {topic}")
+        
+        elif command == "clear_history":
+            response = input("⚠️  Are you sure you want to clear session history? (yes/no): ").strip().lower()
+            if response == "yes":
+                self.session_manager.clear_session_history()
+                print("✅ History cleared.")
+            else:
+                print("❌ Clear cancelled.")
+        
+        elif command == "session":
+            info = self.session_manager.get_session_info()
+            print("📊 Session Information:")
+            for key, value in info.items():
+                print(f"  {key}: {value}")
+        
+        # Help commands
+        elif command == "help":
+            help_cmd = command_args[0] if command_args else None
+            output = self.command_handler.handle_help(help_cmd)
+            print(output)
+        
+        elif command == "commands":
+            output = self.command_handler.handle_commands()
+            print(output)
+        
+        elif command == "about":
+            output = self.command_handler.handle_about()
+            print(output)
+        
+        elif command == "hint":
+            output = self.command_handler.handle_hint(self.current_topic)
+            print(output)
+        
+        elif command == "tip":
+            output = self.command_handler.handle_tip()
+            print(output)
+        
+        elif command == "tips":
+            output = self.command_handler.handle_tips(self.current_topic)
+            print(output)
+        
+        else:
+            print(f"❌ Unknown command: {command}")
+    
+    def _handle_topic_input(self, topic_name: str) -> None:
+        """
+        Handle topic name input.
+        
+        Args:
+            topic_name: Name of the topic to display
+        """
+        topic = self.engine.get_topic(topic_name)
+        
+        if not topic:
+            # Try fuzzy matching
+            from difflib import get_close_matches
+            all_topics = self.engine.list_topics()
+            suggestions = get_close_matches(topic_name, all_topics, n=3, cutoff=0.6)
+            
+            print(f"❌ Topic '{topic_name}' not found.")
+            if suggestions:
+                print("\nDid you mean:")
+                for suggestion in suggestions:
+                    print(f"  • {suggestion}")
+            return
+        
+        self._display_topic(topic_name)
+    
+    def _display_topic(self, topic_name: str) -> None:
+        """
+        Display a topic.
+        
+        Args:
+            topic_name: Name of the topic to display
+        """
+        self.current_topic = topic_name
+        self.session_manager.set_current_topic(topic_name)
+        self.session_manager.mark_topic_viewed(topic_name)
+        
+        output = self.command_handler.format_topic_display(topic_name)
+        print(output)
+    
+    def _run_example(self, example_num: int) -> None:
+        """
+        Run a code example.
+        
+        Args:
+            example_num: Number of the example to run
+        """
+        topic = self.engine.get_topic(self.current_topic)
+        if not topic:
+            print("❌ Topic not found.")
+            return
+        
+        examples = topic.get("examples", [])
+        
+        # Find the example (examples are 1-indexed)
+        if example_num < 1 or example_num > len(examples):
+            print(f"❌ Invalid example number. Available examples: 1-{len(examples)}")
+            return
+        
+        example = examples[example_num - 1]
+        code = example.get("code", "")
+        
+        if not code:
+            print("❌ Example has no code.")
+            return
+        
+        print(f"\n▶️  Running Example {example_num}...\n")
+        
+        success, output = self.code_sandbox.execute(code)
+        
+        if success:
+            print(f"✅ Output:\n{output}")
+            self.session_manager.mark_example_executed(self.current_topic, example_num)
+        else:
+            print(f"❌ Error:\n{output}")
+    
+    def _enter_edit_mode(self, example_num: int) -> None:
+        """
+        Enter edit mode for an example.
+        
+        Args:
+            example_num: Number of the example to edit
+        """
+        topic = self.engine.get_topic(self.current_topic)
+        if not topic:
+            print("❌ Topic not found.")
+            return
+        
+        examples = topic.get("examples", [])
+        
+        if example_num < 1 or example_num > len(examples):
+            print(f"❌ Invalid example number. Available examples: 1-{len(examples)}")
+            return
+        
+        example = examples[example_num - 1]
+        code = example.get("code", "")
+        
+        if not code:
+            print("❌ Example has no code.")
+            return
+        
+        self.in_edit_mode = True
+        self.edit_topic = self.current_topic
+        self.edit_example_num = example_num
+        self.edit_code = code
+        
+        print(f"\n✏️  Editing Example {example_num}:")
+        print("=" * 50)
+        print(self.edit_code)
+        print("=" * 50)
+        print("Enter new code (type /exit_edit when done):")
+    
+    def _exit_edit_mode(self) -> None:
+        """
+        Exit edit mode and execute the modified code.
+        """
+        if not self.in_edit_mode:
+            print("❌ Not in edit mode.")
+            return
+        
+        print(f"\n▶️  Running modified Example {self.edit_example_num}...\n")
+        
+        success, output = self.code_sandbox.execute(self.edit_code)
+        
+        if success:
+            print(f"✅ Output:\n{output}")
+            self.session_manager.mark_example_executed(self.current_topic, self.edit_example_num)
+        else:
+            print(f"❌ Error:\n{output}")
+        
+        self.in_edit_mode = False
+        self.edit_topic = None
+        self.edit_example_num = None
+        self.edit_code = ""
+    
+    def _navigate_next(self) -> None:
+        """Navigate to the next topic in the learning path."""
+        path = self.engine.get_learning_path()
+        
+        if not self.current_topic:
+            if path:
+                self._display_topic(path[0])
+            else:
+                print("❌ No topics available.")
+            return
+        
+        try:
+            current_index = path.index(self.current_topic)
+            if current_index < len(path) - 1:
+                next_topic = path[current_index + 1]
+                self._display_topic(next_topic)
+            else:
+                print("📍 You are at the last topic in the learning path.")
+        except ValueError:
+            print("❌ Current topic not in learning path.")
+    
+    def _navigate_prev(self) -> None:
+        """Navigate to the previous topic in the learning path."""
+        path = self.engine.get_learning_path()
+        
+        if not self.current_topic:
+            print("❌ No current topic.")
+            return
+        
+        try:
+            current_index = path.index(self.current_topic)
+            if current_index > 0:
+                prev_topic = path[current_index - 1]
+                self._display_topic(prev_topic)
+            else:
+                print("📍 You are at the first topic in the learning path.")
+        except ValueError:
+            print("❌ Current topic not in learning path.")
+    
+    def _navigate_to_topic(self, topic_name: str) -> None:
+        """
+        Navigate to a specific topic.
+        
+        Args:
+            topic_name: Name of the topic to navigate to
+        """
+        if not topic_name:
+            print("❌ Please provide a topic name.\nUsage: /goto <topic_name>")
+            return
+        
+        self._handle_topic_input(topic_name)