feat: Language adapter architecture (Phase 0-2)

- Phase 0: Language context management & simplified slug format
  * Add language state in internal.py (get/set_current_language)
  * Pass language to subprocesses via CROSS_PROCESS_ATTRIBUTES
  * Simplify parse_slug() to 2-part format only (course/stage)
  * Add 36 tests covering internal & slug parsing (82 total, 100% pass)

- Phase 1: Adapter pattern for multi-language support
  * base.py: LanguageAdapter ABC with compile/run/exists
  * conventions.py: Naming rules for 8 languages (C, C++, Java, Python, Go, Rust, JS, TS)
  * compiled.py: Concrete adapters for compiled & interpreted languages
  * factory.py: create_adapter() with auto-detection
  * Add get_adapter() convenience function in check/__init__.py
  * Add 41 adapter tests (123 total, 100% pass)

- Phase 2: Hello check migration (unified multi-language)
  * Migrate cs50/hello to use adapters (22 lines vs 810 lines = 97.3% reduction)
  * Support C, Java, Python with single check script
  * Add integration tests & student code samples
  * All 129 tests passing (126 unit + 3 integration + 61 subtests)

Key improvements:
- Code reduction: 810 lines → 22 lines (97.3% less code)
- Zero configuration for 80% use cases (convention over configuration)
- Unified API: get_adapter().require_exists(), compile(), run().stdout().exit()
- Extensible: Easy to add new languages via conventions

Author: william-yangbo

bootcs/__main__.py

@@ -105,28 +105,23 @@ def main():
 
 def parse_slug(slug: str):
     """
-    Parse a slug into course, language, and stage components.
+    Parse a slug into course and stage components.
     
-    Supports two formats:
-    - 2 parts: "cs50/hello" -> (course="cs50", language=None, stage="hello")
-    - 3 parts: "cs50/c/hello" -> (course="cs50", language="c", stage="hello")
+    MVP: Only supports 2-part format "cs50/hello"
+    Language is determined separately via CLI flag or auto-detection.
     
     Returns:
-        tuple: (course_slug, language_from_slug, stage_slug)
-        - language_from_slug is None if slug has 2 parts
+        tuple: (course_slug, stage_slug)
     """
     parts = slug.split("/")
-    if len(parts) == 3:
-        course_slug, lang, stage_slug = parts
-        # Validate that middle part looks like a language
-        if lang in SUPPORTED_LANGUAGES:
-            return course_slug, lang, stage_slug
-        # If middle part doesn't look like a language, treat as 2-part with nested stage
-        return parts[0], None, "/".join(parts[1:])
-    elif len(parts) == 2:
-        return parts[0], None, parts[1]
+    if len(parts) == 2:
+        return parts[0], parts[1]
+    elif len(parts) == 1:
+        # Single part, treat as stage only
+        return None, parts[0]
     else:
-        return None, None, slug
+        # Multi-part, treat first as course, last as stage
+        return parts[0], "/".join(parts[1:])
 
 
 def detect_language(directory: Path = None, explicit: str = None) -> str:
@@ -178,19 +173,16 @@ def run_check(args):
     slug = args.slug
     force_update = getattr(args, 'update', False)
 
-    # Parse slug to extract language if present (e.g., "cs50/c/hello")
-    course_slug, lang_from_slug, stage_slug = parse_slug(slug)
+    # Parse slug (MVP: only 2-part format)
+    course_slug, stage_slug = parse_slug(slug)
 
-    # Determine language: slug > explicit flag > auto-detect
+    # Determine language via explicit flag or auto-detection
     explicit_lang = getattr(args, 'language', None)
-    if lang_from_slug:
-        language = lang_from_slug
-    else:
-        language = detect_language(directory=Path.cwd(), explicit=explicit_lang)
+    language = detect_language(directory=Path.cwd(), explicit=explicit_lang)
 
     # Determine check directory
     if args.local:
-        # Combine local path with slug (e.g., /path/to/checks + cs50/python/hello)
+        # Combine local path with slug (e.g., /path/to/checks + cs50/hello)
         check_dir = Path(args.local).resolve() / slug
     else:
         # Try remote download first, then fall back to local search
@@ -239,7 +231,7 @@ def run_check(args):
     targets = args.target if hasattr(args, 'target') and args.target else None
 
     try:
-        with CheckRunner(checks_file, list(included)) as runner:
+        with CheckRunner(checks_file, list(included), language=language) as runner:
             results = runner.run(targets=targets)
     except Exception as e:
         termcolor.cprint(f"Error running checks: {e}", "red", file=sys.stderr)
@@ -341,47 +333,34 @@ def find_check_dir(slug, language: str = "c", force_update: bool = False):
     """
     Find the check directory for a given slug.
     
-    Supports two slug formats:
-    - 2 parts: "cs50/hello" (language auto-detected or passed as parameter)
-    - 3 parts: "cs50/c/hello" (language extracted from slug)
+    MVP: Only supports 2-part format "cs50/hello"
+    Language is determined separately and not part of the path.
     
     Priority:
     1. BOOTCS_CHECKS_PATH environment variable (for evaluator)
     2. Remote API download (with local cache)
     3. Local directories (for development)
     """
-    # Use parse_slug to extract components
-    course_slug, lang_from_slug, stage_name = parse_slug(slug)
-    
-    # If slug contains language, use it; otherwise use provided parameter
-    if lang_from_slug:
-        language = lang_from_slug
+    # Parse slug (MVP: only 2-part format)
+    course_slug, stage_name = parse_slug(slug)
 
     # 1. Check environment variable first (used by evaluator)
     if "BOOTCS_CHECKS_PATH" in os.environ:
         checks_path = Path(os.environ["BOOTCS_CHECKS_PATH"])
-        # Try with course/language/stage structure (e.g., checks/cs50/c/hello)
+        # Try with course/stage structure (e.g., checks/cs50/hello)
         if course_slug:
-            path = checks_path / course_slug / language / stage_name
+            path = checks_path / course_slug / stage_name
             if path.exists():
                 return path
-        # Try with language/stage structure (e.g., checks/c/hello)
-        path = checks_path / language / stage_name
-        if path.exists():
-            return path
-        # Try with full slug under language
+        # Fallback: try with full slug
         if course_slug:
-            path = checks_path / language / slug
+            path = checks_path / slug
             if path.exists():
                 return path
-        # Fallback: try without language prefix
+        # Try stage name only
         path = checks_path / stage_name
         if path.exists():
             return path
-        if course_slug:
-            path = checks_path / slug
-            if path.exists():
-                return path
 
     # 2. Try remote download (if slug has course/stage format)
     if course_slug:
@@ -531,15 +510,12 @@ def run_submit(args):
 
     slug = args.slug
 
-    # Parse slug to extract language if present (e.g., "cs50/c/hello")
-    course_slug, lang_from_slug, stage_slug = parse_slug(slug)
+    # Parse slug (MVP: only 2-part format)
+    course_slug, stage_slug = parse_slug(slug)
 
-    # Determine language: slug > explicit flag > auto-detect
+    # Determine language via explicit flag or auto-detection
     explicit_lang = getattr(args, 'language', None)
-    if lang_from_slug:
-        language = lang_from_slug
-    else:
-        language = detect_language(directory=Path.cwd(), explicit=explicit_lang)
+    language = detect_language(directory=Path.cwd(), explicit=explicit_lang)
 
     # Check if logged in
     if not is_logged_in():

bootcs/check/__init__.py

@@ -32,6 +32,27 @@ def _(s):
 from .runner import check
 from pexpect import EOF
 
+# Phase 1: Language adapters
+from .adapters import LanguageAdapter, create_adapter
+
+
+def get_adapter():
+    """
+    Get language adapter for current check context.
+    
+    Automatically retrieves problem name and language from internal state.
+    Convenience function to avoid repetition in check implementations.
+    
+    Returns:
+        LanguageAdapter: Configured adapter for current problem/language
+    """
+    problem = internal.get_problem_name()
+    language = internal.get_current_language()
+    return create_adapter(problem, language)
+
+
 __all__ = ["import_checks", "data", "exists", "hash", "include", "regex",
            "run", "log", "Failure", "Mismatch", "Missing", "check", "EOF",
-           "c", "java", "internal", "hidden"]
+           "c", "java", "internal", "hidden",
+           # Phase 1: Adapters
+           "LanguageAdapter", "create_adapter", "get_adapter"]

bootcs/check/adapters/__init__.py

@@ -0,0 +1,17 @@
+"""
+Language adapters for bootcs check system.
+
+This module provides language-agnostic adapters that abstract away
+language-specific details for compilation, execution, and testing.
+
+Based on check50 by CS50 (https://github.com/cs50/check50)
+Licensed under GPL-3.0
+"""
+
+from .base import LanguageAdapter
+from .factory import create_adapter
+
+__all__ = [
+    "LanguageAdapter",
+    "create_adapter",
+]

bootcs/check/adapters/base.py

@@ -0,0 +1,123 @@
+"""
+Base language adapter for bootcs check system.
+
+Provides the abstract interface that all language adapters must implement.
+
+Based on check50 by CS50 (https://github.com/cs50/check50)
+Licensed under GPL-3.0
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Optional, List
+
+
+class LanguageAdapter(ABC):
+    """
+    Abstract base class for language adapters.
+    
+    Each language adapter abstracts the details of compiling, running,
+    and testing programs in a specific programming language.
+    
+    Attributes:
+        problem (str): The problem name (e.g., "hello", "mario-less")
+        language (str): The programming language (e.g., "c", "python", "java")
+    """
+    
+    def __init__(self, problem: str, language: str = None):
+        """
+        Initialize the language adapter.
+        
+        Args:
+            problem: Problem name (e.g., "hello")
+            language: Programming language (auto-detected if None)
+        """
+        self.problem = problem
+        self.language = language or self._detect_language()
+    
+    @abstractmethod
+    def _detect_language(self) -> str:
+        """
+        Detect the programming language from available files.
+        
+        Returns:
+            Detected language string (e.g., "c", "python", "java")
+        """
+        pass
+    
+    @abstractmethod
+    def get_source_file(self) -> Path:
+        """
+        Get the main source file path for this problem.
+        
+        Returns:
+            Path to the source file (e.g., hello.c, Hello.java, hello.py)
+        
+        Raises:
+            FileNotFoundError: If source file doesn't exist
+        """
+        pass
+    
+    @abstractmethod
+    def compile(self, *args, **kwargs):
+        """
+        Compile the source code (if needed for this language).
+        
+        For interpreted languages, this may be a no-op or perform validation.
+        For compiled languages, this compiles the source to executable/bytecode.
+        
+        Args:
+            *args: Language-specific compilation arguments
+            **kwargs: Language-specific compilation options
+        
+        Raises:
+            CompileError: If compilation fails
+        """
+        pass
+    
+    @abstractmethod
+    def run(self, *args, stdin=None, **kwargs):
+        """
+        Run the compiled/interpreted program.
+        
+        Args:
+            *args: Command-line arguments to pass to the program
+            stdin: Standard input to provide to the program
+            **kwargs: Language-specific execution options
+        
+        Returns:
+            The result object from the execution (depends on implementation)
+        """
+        pass
+    
+    def exists(self) -> bool:
+        """
+        Check if the source file exists.
+        
+        Returns:
+            True if source file exists, False otherwise
+        """
+        try:
+            source = self.get_source_file()
+            return source.exists()
+        except FileNotFoundError:
+            return False
+    
+    def require_exists(self):
+        """
+        Ensure source file exists, raise Failure if not.
+        
+        This is a convenience method for check implementations.
+        Instead of: if not adapter.exists(): raise Failure(...)
+        Use: adapter.require_exists()
+        
+        Raises:
+            Failure: If source file doesn't exist
+        """
+        from .. import Failure
+        if not self.exists():
+            raise Failure("Expected source file")
+    
+    def __repr__(self):
+        """String representation of the adapter."""
+        return f"{self.__class__.__name__}(problem={self.problem!r}, language={self.language!r})"