IncludeCPP 3.3.11__py3-none-any.whl → 3.4.2__py3-none-any.whl

includecpp/cli/commands.py

@@ -10,6 +10,22 @@ import urllib.error
 from pathlib import Path
 from .config_parser import CppProjectConfig
 
+
+def _is_experimental_enabled() -> bool:
+    """Check if experimental features (cppy, ai) are enabled."""
+    config_path = Path.home() / '.includecpp' / '.secret'
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text())
+            return config.get('experimental_features', False)
+        except:
+            pass
+    return False
+
+
+# Check once at module load time
+_EXPERIMENTAL_ENABLED = _is_experimental_enabled()
+
 # Unicode fallback for Windows terminals with limited encoding
 def _supports_unicode():
     """Check if terminal supports Unicode output."""
@@ -49,7 +65,7 @@ def _safe_echo(text, **kwargs):
             ('╔', '+'), ('╗', '+'), ('╚', '+'), ('╝', '+'),
             ('┌', '+'), ('┐', '+'), ('└', '+'), ('┘', '+'),
             ('═', '-'), ('─', '-'), ('║', '|'), ('│', '|'),
-            ('✗', '[X]'), ('•', '*'),
+            ('✗', '[X]'), ('✓', '[OK]'), ('❌', '[X]'), ('•', '*'),
             ('→', '->'), ('▶', '>'), ('◆', '*'),
             ('\u2011', '-'), ('\u2010', '-'),
             ('\u2013', '-'), ('\u2014', '--'),
@@ -133,13 +149,13 @@ def _render_readme_with_colors(readme_text):
 
 def _show_changelog():
     """Extract and display changelog from README."""
-    click.echo("=" * 70)
-    click.secho("IncludeCPP Changelog", fg='cyan', bold=True)
-    click.echo("=" * 70)
-    click.echo()
+    _safe_echo("=" * 70)
+    _safe_echo("IncludeCPP Changelog", fg='cyan', bold=True)
+    _safe_echo("=" * 70)
+    _safe_echo("")
 
     try:
-        click.echo("  Fetching changelog from PyPI...", nl=False)
+        _safe_echo("  Fetching changelog from PyPI...", nl=False)
         req = urllib.request.Request(
             "https://pypi.org/pypi/IncludeCPP/json",
             headers={"User-Agent": "IncludeCPP-CLI"}
@@ -150,12 +166,12 @@ def _show_changelog():
         data = json.loads(raw_data)
         description = data.get('info', {}).get('description', '')
         version = data.get('info', {}).get('version', 'unknown')
-        click.secho(" OK", fg='green')
-        click.echo()
+        _safe_echo(" OK", fg='green')
+        _safe_echo("")
 
         if description:
-            click.secho(f"Current Version: {version}", fg='green', bold=True)
-            click.echo()
+            _safe_echo(f"Current Version: {version}", fg='green', bold=True)
+            _safe_echo("")
 
             lines = description.split('\n')
             in_changelog = False
@@ -174,23 +190,23 @@ def _show_changelog():
                 for line in changelog_lines:
                     stripped = line.strip()
                     if stripped.startswith('## '):
-                        click.secho(stripped[3:], fg='yellow', bold=True)
+                        _safe_echo(stripped[3:], fg='yellow', bold=True)
                     elif stripped.startswith('- '):
-                        click.echo("  " + stripped)
+                        _safe_echo("  " + stripped)
                     elif stripped:
-                        click.echo("  " + stripped)
+                        _safe_echo("  " + stripped)
             else:
-                click.secho("No changelog found in README.", fg='yellow')
+                _safe_echo("No changelog found in README.", fg='yellow')
         else:
-            click.secho("No documentation available.", fg='yellow')
+            _safe_echo("No documentation available.", fg='yellow')
 
     except Exception as e:
-        click.secho(" FAILED", fg='red')
-        click.echo()
-        click.secho("Could not fetch changelog: " + str(e), fg='red', err=True)
+        _safe_echo(" FAILED", fg='red')
+        _safe_echo("")
+        _safe_echo("Could not fetch changelog: " + str(e), fg='red', err=True)
 
-    click.echo()
-    click.echo("=" * 70)
+    _safe_echo("")
+    _safe_echo("=" * 70)
 
 
 @click.group(invoke_without_command=True)
@@ -4420,8 +4436,10 @@ def fix(module_name, all_modules, exclude, undo, auto_fix, verbose, use_ai):
             if var_decl:
                 var_name = var_decl.group(1)
                 # Check if variable appears again in rest of content
+                # v3.4.1: Use word boundaries to avoid false positives from substring matches
                 rest_content = '\n'.join(lines[i:])
-                if rest_content.count(var_name) <= 1:
+                uses = len(re.findall(rf'\b{re.escape(var_name)}\b', rest_content))
+                if uses <= 1:
                     add_issue('info', 'Mistake', file_path, i, 'C003',
                               f"Variable '{var_name}' may be unused",
                               "Remove unused variable or mark as [[maybe_unused]]")
@@ -4816,7 +4834,8 @@ def fix(module_name, all_modules, exclude, undo, auto_fix, verbose, use_ai):
     click.echo(f"{'='*60}")
 
 
-@cli.group(invoke_without_command=True)
+# AI group - conditionally registered based on experimental_features setting
+@click.group(invoke_without_command=True)
 @click.option('--info', is_flag=True, help='Show AI status and usage')
 @click.pass_context
 def ai(ctx, info):
@@ -5306,7 +5325,7 @@ def ai_edit(task, module_name, files, all_modules, exclude, think_mode, think_tw
         question = None  # Continuation doesn't ask more questions
 
     if not changes:
-        verbose.status("No changes needed", success=True)
+        verbose.status("No changes needed", phase='complete')
         verbose.end(success=True, message="No changes required")
         return
 
@@ -5520,7 +5539,7 @@ def ai_generate(task, files, think_mode, think_twice, think_three, use_websearch
     verbose.api_call(endpoint='chat/completions', tokens_out=len(str(changes)) // 4 if changes else len(response) // 4)
 
     if not changes:
-        verbose.status("No file changes needed", success=True)
+        verbose.status("No file changes needed", phase='complete')
         # Show response if any
         if response:
             _safe_echo(f"\n{response[:2000]}")
@@ -5598,7 +5617,7 @@ def ai_generate(task, files, think_mode, think_twice, think_three, use_websearch
             shell=True, capture_output=True, text=True, cwd=project_root
         )
         if result.returncode == 0:
-            verbose.status("Plugin generated", success=True)
+            verbose.status("Plugin generated", phase='complete')
         else:
             verbose.error(f"Plugin error: {result.stderr[:100]}")
             verbose.end(success=False, message="Plugin generation failed")
@@ -5611,7 +5630,7 @@ def ai_generate(task, files, think_mode, think_twice, think_three, use_websearch
             shell=True, capture_output=True, text=True, cwd=project_root
         )
         if result.returncode == 0:
-            verbose.status("Build successful", success=True)
+            verbose.status("Build successful", phase='complete')
         else:
             verbose.error(f"Build error: {result.stderr[:100]}")
 
@@ -5719,7 +5738,7 @@ def ai_optimize(module_name, files, agent_task, auto_confirm, no_verbose):
 
     verbose.phase('analyzing', 'Analyzing code for optimization opportunities')
     for fp in files_to_optimize.keys():
-        verbose.status(f"Scanning {Path(fp).name}", success=True)
+        verbose.status(f"Scanning {Path(fp).name}", phase='analyzing')
 
     verbose.phase('thinking', 'AI is analyzing and planning optimizations')
     verbose.api_call(endpoint='chat/completions', tokens_in=total_lines * 4)
@@ -5734,7 +5753,7 @@ def ai_optimize(module_name, files, agent_task, auto_confirm, no_verbose):
     verbose.api_call(endpoint='chat/completions', tokens_out=len(str(changes)) // 4 if changes else 0)
 
     if not changes:
-        verbose.status("No optimizations needed", success=True)
+        verbose.status("No optimizations needed", phase='complete')
         verbose.end(success=True, message="Code is already optimal")
         return
 
@@ -5787,7 +5806,7 @@ def ai_optimize(module_name, files, agent_task, auto_confirm, no_verbose):
                         click.secho("CONFIRM REQUIRED:", fg='yellow', bold=True)
                         click.echo(f"\n{confirm}\n")
                         if not click.confirm("Apply this change?"):
-                            verbose.status(f"Skipped: {change['file']}", success=False)
+                            verbose.status(f"Skipped: {change['file']}", phase='warning')
                             changes = [c for c in changes if c != change]
         if not click.confirm("Apply all changes?"):
             verbose.warning("Changes aborted by user")
@@ -5848,11 +5867,59 @@ def settings():
         click.echo("  includecpp ai key <YOUR_KEY>")
 
 
+@click.command()
+@click.option('--path', '-p', type=click.Path(), default=None,
+              help='Path to project directory (default: current directory)')
+def project(path):
+    """Open the Project Interface with CodeMaker.
+
+    Opens a professional visual mindmap tool for planning and designing
+    your C++ project structure.
+
+    Features:
+    - Visual node-based system design
+    - Class, Function, Object, and Definition nodes
+    - Connectable nodes with bezier curves
+    - Pan/zoom navigation (middle mouse button)
+    - Auto-save functionality
+    - .ma map file management
+
+    Controls:
+    - Right-click canvas: Create new nodes
+    - Right-click node: Edit/Connect/Delete
+    - Middle mouse + drag: Pan view
+    - Middle mouse + scroll: Zoom in/out
+    - ESC: Cancel connection mode
+    - DELETE: Remove selected nodes
+
+    Requires: pip install PyQt6
+    """
+    from pathlib import Path as PathLib
+    project_path = PathLib(path) if path else PathLib.cwd()
+
+    if not project_path.exists():
+        click.secho(f"Path does not exist: {project_path}", fg='red', err=True)
+        return
+
+    try:
+        from ..core.project_ui import show_project, PYQT_AVAILABLE
+        if not PYQT_AVAILABLE:
+            click.secho("PyQt6 not installed.", fg='red', err=True)
+            click.echo("Install with: pip install PyQt6")
+            return
+        success, msg = show_project(str(project_path))
+        if not success:
+            click.secho(msg, fg='red', err=True)
+    except Exception as e:
+        click.secho(f"Error opening project interface: {e}", fg='red', err=True)
+
+
 # ============================================================================
-# CPPY - Code Conversion Tools
+# CPPY - Code Conversion Tools (Experimental)
 # ============================================================================
 
-@cli.group(invoke_without_command=True)
+# CPPY group - conditionally registered based on experimental_features setting
+@click.group(invoke_without_command=True)
 @click.pass_context
 def cppy(ctx):
     """Code conversion tools for Python <-> C++.
@@ -6358,6 +6425,38 @@ def _convert_with_ai(content: str, module_name: str, source_file,
                 return _convert_to_python(content, module_name, source_file, output_dir, verbose)
 
         ai_verbose.api_call(endpoint='chat/completions', tokens_out=len(response) // 4)
+
+        # Check if AI needs clarification on unconvertible modules
+        if 'CLARIFICATION_NEEDED:' in response:
+            ai_verbose.phase('clarification', 'AI needs clarification')
+            clarification_match = re.search(r'CLARIFICATION_NEEDED:\n((?:- .+\n?)+)', response)
+            if clarification_match:
+                questions = clarification_match.group(1).strip()
+                click.echo("\n" + "=" * 60)
+                click.secho("AI NEEDS CLARIFICATION:", fg='yellow', bold=True)
+                click.echo(questions)
+                click.echo("=" * 60)
+                user_input = click.prompt("Your response (or 'skip' to use defaults)")
+                if user_input.lower() != 'skip':
+                    # Re-run AI with user's clarification
+                    clarified_prompt = ai_prompt + f"\n\nUSER CLARIFICATION:\n{user_input}\n\nNow convert with this clarification:"
+                    success, response, _ = ai_manager.generate(
+                        task=clarified_prompt,
+                        files={str(source_file): content},
+                        project_root=project_root,
+                        think=think,
+                        think_twice=think_twice,
+                        think_three=think_three,
+                        use_websearch=use_websearch,
+                        skip_tool_execution=True
+                    )
+                    if not success:
+                        ai_verbose.warning("Clarified conversion failed, using standard converter")
+                        if to_cpp:
+                            return _convert_to_cpp(content, module_name, source_file, output_dir, no_header, namespace, verbose)
+                        else:
+                            return _convert_to_python(content, module_name, source_file, output_dir, verbose)
+
         ai_verbose.phase('parsing', 'Extracting converted code from AI response')
 
         # Parse AI response
@@ -6367,7 +6466,7 @@ def _convert_with_ai(content: str, module_name: str, source_file,
         converted_code = _extract_ai_converted_code(response, to_cpp, module_name, namespace)
 
         if not converted_code:
-            ai_verbose.status("Using hybrid conversion (AI + standard)", success=True)
+            ai_verbose.status("Using hybrid conversion (AI + standard)", phase='complete')
             # Fall back to standard conversion with AI enhancements
             if to_cpp:
                 converter = PythonToCppConverter()
@@ -6460,22 +6559,95 @@ def _convert_with_ai(content: str, module_name: str, source_file,
     return result
 
 
+def _get_includecpp_readme() -> str:
+    """Load IncludeCPP README.md for AI context."""
+    try:
+        import importlib.resources
+        import includecpp
+        readme_path = Path(includecpp.__file__).parent.parent / 'README.md'
+        if readme_path.exists():
+            readme = readme_path.read_text(encoding='utf-8')
+            # Truncate to first sections (keep it focused)
+            sections = readme.split('# Changelog')[0]  # Everything before changelog
+            return sections[:8000]  # Limit to ~8k chars
+    except Exception:
+        pass
+    return ""
+
 def _build_cppy_ai_prompt(source: str, mode: str, module_name: str, namespace: str, analysis: dict, no_header: bool = False) -> str:
     """Build AI prompt with IncludeCPP-specific instructions."""
 
+    # Load README for AI context (dynamically, not hardcoded)
+    readme_context = _get_includecpp_readme()
+    includecpp_docs = ""
+    if readme_context:
+        includecpp_docs = f'''
+=== INCLUDECPP DOCUMENTATION (from README.md) ===
+{readme_context}
+=== END DOCUMENTATION ===
+'''
+
+    # Critical file extension rules
+    file_rules = f'''
+CRITICAL FILE EXTENSION RULES:
+- C++ implementation file MUST be: {module_name}.cpp (NOT .cp, NOT .cc, NOT .cxx)
+- C++ header file MUST be: {module_name}.h (NOT .hpp, NOT .hh)
+- Python file MUST be: {module_name}.py
+FOLLOW THESE EXTENSIONS EXACTLY.
+'''
+
+    # Unconvertible module handling
+    unconvertible_info = ""
+    for item, reason, line in getattr(analysis.get('converter', None), 'unconvertible', []) if isinstance(analysis, dict) else []:
+        unconvertible_info += f"- Line {line}: {item} ({reason})\n"
+
+    unconvertible_guidance = ""
+    if unconvertible_info:
+        unconvertible_guidance = f'''
+UNCONVERTIBLE MODULES DETECTED:
+{unconvertible_info}
+
+For unconvertible modules (tkinter, pygame, ursina, etc.):
+1. COMMENT OUT: Add /* UNCONVERTIBLE: tkinter */ comment
+2. ALTERNATIVE: Suggest C++ alternatives (Qt for GUI, SDL2 for games, etc.)
+3. SKIP: Remove the code with explanation comment
+
+If you need clarification, output:
+CLARIFICATION_NEEDED:
+- <what you need clarified>
+'''
+
     if mode == 'py_to_cpp':
         direction = "Python to C++"
         source_lang = "python"
         target_lang = "cpp"
 
+        # CRITICAL: No pybind11 - IncludeCPP handles bindings automatically
+        includecpp_note = '''
+**CRITICAL - IncludeCPP HANDLES BINDINGS AUTOMATICALLY:**
+- DO NOT include pybind11 headers
+- DO NOT write PYBIND11_MODULE macros
+- DO NOT use py:: namespace or py::object
+- Just write CLEAN C++ code in namespace includecpp
+- IncludeCPP will auto-generate Python bindings via: includecpp plugin <name> <file.cpp>
+
+The user runs:
+1. includecpp cppy convert file.py --cpp  (generates .cpp)
+2. includecpp plugin mymod file.cpp       (auto-generates pybind11 bindings)
+3. includecpp rebuild                     (compiles to Python module)
+'''
+
         if no_header:
             # No header mode - put everything in .cpp
             specific_rules = f'''
 INCLUDECPP-SPECIFIC REQUIREMENTS:
 1. ALL code MUST be wrapped in: namespace {namespace} {{ ... }}
-2. DO NOT create a header file - put ALL code in the .cpp file only
-3. Include declarations at the top of the .cpp file (no separate .h)
-4. For Python features without C++ equivalent, use pybind11 wrappers
+2. **CRITICAL: DO NOT create a header file** - --no-h flag is set
+3. Put ALL declarations AND implementations in the .cpp file only
+4. NO separate .h file should be created
+{includecpp_note}
+
+{file_rules}
 
 TYPE CONVERSIONS:
 - int -> int
@@ -6487,8 +6659,14 @@ TYPE CONVERSIONS:
 - Set[T] -> std::unordered_set<T>
 - Optional[T] -> std::optional<T>
 - Callable -> std::function<R(Args...)>
-- Any -> auto or py::object
-'''
+- bytes -> std::vector<uint8_t>
+
+GENERIC/TEMPLATE FUNCTIONS:
+- For functions that accept any type (like choices), use C++ templates:
+  template<typename T> T getRandomChoice(const std::vector<T>& choices);
+- NOT: auto getRandomChoice(const std::vector<auto>& choices)  // INVALID!
+
+{unconvertible_guidance}'''
         else:
             # Normal mode with header
             specific_rules = f'''
@@ -6497,22 +6675,30 @@ INCLUDECPP-SPECIFIC REQUIREMENTS:
 2. Create BOTH .cpp implementation AND .h header file
 3. Use #include "{module_name}.h" at top of .cpp file
 4. Header guard: #ifndef {module_name.upper()}_H / #define / #endif
-5. For Python features without C++ equivalent, use pybind11 wrappers:
-   - Generators: Use callback pattern or py::iterator
-   - Dynamic attributes: Use py::object
-   - Context managers: Use RAII pattern
-   - Duck typing: Use templates with concepts
+{includecpp_note}
+
+{file_rules}
 
-PYBIND11 WRAPPER PATTERN (for unconvertible features):
+GENERIC/TEMPLATE FUNCTIONS:
+- For functions that accept any type, use C++ templates:
+  template<typename T> T getRandomChoice(const std::vector<T>& choices);
+- NOT: auto getRandomChoice(const std::vector<auto>& choices)  // INVALID!
+
+TEMPLATE EXAMPLE (for generic functions):
 ```cpp
-#include <pybind11/pybind11.h>
-namespace py = pybind11;
+// In header (.h):
+template<typename T>
+T getRandomChoice(const std::vector<T>& choices);
 
-// For Python module calls that can't be converted:
-py::object call_python_func(const std::string& module, const std::string& func) {{
-    py::module_ mod = py::module_::import(module.c_str());
-    return mod.attr(func.c_str())();
+// In implementation (.cpp):
+template<typename T>
+T Manager::getRandomChoice(const std::vector<T>& choices) {{
+    // implementation
 }}
+// Explicit instantiations for common types:
+template int Manager::getRandomChoice<int>(const std::vector<int>&);
+template double Manager::getRandomChoice<double>(const std::vector<double>&);
+template std::string Manager::getRandomChoice<std::string>(const std::vector<std::string>&);
 ```
 
 TYPE CONVERSIONS:
@@ -6520,13 +6706,14 @@ TYPE CONVERSIONS:
 - float -> double
 - str -> std::string
 - bool -> bool
+- bytes -> std::vector<uint8_t>
 - List[T] -> std::vector<T>
 - Dict[K,V] -> std::unordered_map<K,V>
 - Set[T] -> std::unordered_set<T>
 - Optional[T] -> std::optional<T>
 - Callable -> std::function<R(Args...)>
-- Any -> auto or py::object
-'''
+
+{unconvertible_guidance}'''
     else:
         direction = "C++ to Python"
         source_lang = "cpp"
@@ -6559,37 +6746,60 @@ TYPE CONVERSIONS:
     # Build output format based on mode and no_header flag
     if mode == 'py_to_cpp':
         if no_header:
-            output_format = f'''OUTPUT FORMAT (NO HEADER - .cpp only):
-1. Output ONLY the .cpp file content:
+            output_format = f'''OUTPUT FORMAT (--no-h flag is set, NO HEADER FILE):
+**CRITICAL**: Output ONLY a single .cpp file. NO .h file allowed.
+
+Output the implementation file (extension MUST be .cpp):
 ```cpp
 // {module_name}.cpp
-<full cpp content with all declarations and implementations>
+#include <string>
+#include <vector>
+// ... other includes ...
+
+namespace {namespace} {{
+
+// All declarations AND implementations go here
+// No forward declarations needed since everything is in one file
+
+}} // namespace {namespace}
 ```
 
-IMPORTANT: Do NOT output a header file. Put everything in .cpp.'''
+REMEMBER:
+- File extension is .cpp (NOT .cp, NOT .cc)
+- DO NOT create a .h header file
+- Put ALL code in the single .cpp file'''
         else:
             output_format = f'''OUTPUT FORMAT (with header):
-1. First output the .cpp file content:
+1. First output the implementation file (extension MUST be .cpp):
 ```cpp
 // {module_name}.cpp
-<full cpp content>
+#include "{module_name}.h"
+// ... implementations ...
 ```
 
-2. Then the header file (REQUIRED):
+2. Then output the header file (extension MUST be .h):
 ```cpp
 // {module_name}.h
-<full header content>
-```'''
+#ifndef {module_name.upper()}_H
+#define {module_name.upper()}_H
+// ... declarations ...
+#endif // {module_name.upper()}_H
+```
+
+REMEMBER:
+- Implementation file extension is .cpp (NOT .cp, NOT .cc)
+- Header file extension is .h (NOT .hpp, NOT .hh)'''
     else:
         output_format = f'''OUTPUT FORMAT:
-Output the Python file:
+Output the Python file (extension MUST be .py):
 ```python
 # {module_name}.py
 <full python content>
 ```'''
 
     prompt = f'''Convert the following {direction}.
-
+You are IncludeCPP's AI code converter. Follow all requirements precisely.
+{includecpp_docs}
 MODULE NAME: {module_name}
 NAMESPACE: {namespace}
 {specific_rules}
@@ -6602,6 +6812,10 @@ SOURCE CODE ({source_lang}):
 
 {output_format}
 
+If you need clarification about how to convert specific modules or patterns:
+CLARIFICATION_NEEDED:
+- <specific question about conversion approach>
+
 At the end, list any API changes:
 API_CHANGES:
 - <change description>
@@ -6921,5 +7135,394 @@ def cppy_types():
     click.echo("=" * 60)
 
 
+# ============================================================================
+# EXEC - Interactive Code Execution
+# ============================================================================
+
+@cli.command()
+@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++']))
+@click.argument('path', required=False, type=click.Path())
+@click.option('--all', 'import_all', is_flag=True, help='Import all available modules')
+def exec(lang, path, import_all):
+    """Execute code interactively for quick testing.
+
+    Run Python or C++ code snippets without creating files.
+    Perfect for testing your IncludeCPP modules quickly.
+
+    \b
+    Usage:
+      includecpp exec py              # Interactive Python
+      includecpp exec cpp             # Interactive C++
+      includecpp exec py mymodule     # Auto-import mymodule
+      includecpp exec py plugins/x.cp # Auto-import from plugin
+      includecpp exec py --all        # Import all modules
+
+    \b
+    Controls:
+      ENTER       = Add new line
+      Empty line  = Execute code (press ENTER twice)
+      CTRL+C      = Cancel
+
+    \b
+    Examples:
+      $ includecpp exec py fast_math
+      >>> x = fast_math.add(1, 2)
+      >>> print(x)
+      >>>
+      3
+    """
+    import sys
+    import subprocess
+    import tempfile
+    from pathlib import Path as PathLib
+
+    # Normalize language
+    is_python = lang in ('py', 'python')
+    lang_name = 'Python' if is_python else 'C++'
+
+    # Build imports/includes
+    imports = []
+    includes = []
+
+    if import_all:
+        # Import all available modules
+        try:
+            from ..core.cpp_api import CppApi
+            api = CppApi()
+            modules = list(api.registry.keys())
+            if is_python:
+                for mod in modules:
+                    imports.append(f'from includecpp import {mod}')
+                if modules:
+                    click.secho(f"Auto-importing {len(modules)} modules: {', '.join(modules)}", fg='cyan')
+            else:
+                for mod in modules:
+                    includes.append(f'#include "{mod}.h"')
+                if modules:
+                    click.secho(f"Auto-including {len(modules)} headers", fg='cyan')
+        except Exception:
+            click.secho("Warning: Could not load module registry", fg='yellow')
+
+    elif path:
+        path_obj = PathLib(path)
+        module_name = None
+
+        # Check if it's a .cp plugin file
+        if path.endswith('.cp') or '/plugins/' in path or '\\plugins\\' in path:
+            # Extract module name from plugin path
+            module_name = path_obj.stem
+        elif path_obj.exists():
+            # It's a file path
+            module_name = path_obj.stem
+        else:
+            # Assume it's a module name directly
+            module_name = path
+
+        if module_name:
+            if is_python:
+                imports.append(f'from includecpp import {module_name}')
+                click.secho(f"Auto-importing: {module_name}", fg='cyan')
+            else:
+                includes.append(f'#include "{module_name}.h"')
+                click.secho(f"Auto-including: {module_name}.h", fg='cyan')
+
+    # Show header
+    click.echo()
+    click.secho(f"=== IncludeCPP {lang_name} REPL ===", fg='cyan', bold=True)
+    click.echo("Enter code line by line. Press ENTER on empty line to execute.")
+    click.echo("Press CTRL+C to cancel.")
+    click.echo()
+
+    # Show pre-loaded imports
+    if imports:
+        click.secho("Pre-loaded:", fg='green')
+        for imp in imports:
+            click.echo(f"  {imp}")
+        click.echo()
+
+    if includes:
+        click.secho("Pre-loaded:", fg='green')
+        for inc in includes:
+            click.echo(f"  {inc}")
+        click.echo()
+
+    # Collect code lines
+    lines = []
+    prompt = '>>> ' if is_python else 'cpp> '
+    continuation = '... ' if is_python else '   > '
+
+    try:
+        while True:
+            try:
+                # Determine prompt
+                current_prompt = prompt if not lines else continuation
+                line = input(current_prompt)
+
+                # Empty line = execute
+                if not line.strip():
+                    if lines:
+                        break
+                    continue
+
+                lines.append(line)
+
+            except EOFError:
+                break
+
+    except KeyboardInterrupt:
+        click.echo()
+        click.secho("Cancelled.", fg='yellow')
+        return
+
+    if not lines:
+        click.secho("No code entered.", fg='yellow')
+        return
+
+    # Build full code
+    code_lines = imports + [''] + lines if imports else lines
+
+    click.echo()
+    click.secho("--- Output ---", fg='green')
+
+    if is_python:
+        # Execute Python code
+        full_code = '\n'.join(code_lines)
+        try:
+            # Use exec with captured output
+            import io
+            from contextlib import redirect_stdout, redirect_stderr
+
+            stdout_capture = io.StringIO()
+            stderr_capture = io.StringIO()
+
+            # Create execution context
+            exec_globals = {'__name__': '__main__'}
+
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                exec(full_code, exec_globals)
+
+            stdout_val = stdout_capture.getvalue()
+            stderr_val = stderr_capture.getvalue()
+
+            if stdout_val:
+                click.echo(stdout_val, nl=False)
+            if stderr_val:
+                click.secho(stderr_val, fg='red', nl=False)
+
+            if not stdout_val and not stderr_val:
+                click.secho("(no output)", fg='bright_black')
+
+        except Exception as e:
+            click.secho(f"Error: {e}", fg='red')
+
+    else:
+        # Execute C++ code
+        # Build a complete C++ program
+        cpp_code_lines = [
+            '#include <iostream>',
+            '#include <vector>',
+            '#include <string>',
+            '#include <algorithm>',
+            '#include <cmath>',
+            'using namespace std;',
+            ''
+        ]
+        cpp_code_lines.extend(includes)
+        cpp_code_lines.append('')
+        cpp_code_lines.append('int main() {')
+
+        # Indent user code
+        for line in lines:
+            cpp_code_lines.append('    ' + line)
+
+        cpp_code_lines.append('    return 0;')
+        cpp_code_lines.append('}')
+
+        full_code = '\n'.join(cpp_code_lines)
+
+        # Write to temp file and compile
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.cpp', delete=False, encoding='utf-8') as f:
+            f.write(full_code)
+            cpp_file = f.name
+
+        exe_file = cpp_file.replace('.cpp', '.exe' if sys.platform == 'win32' else '')
+
+        try:
+            # Compile
+            compile_cmd = ['g++', '-std=c++17', '-o', exe_file, cpp_file]
+            result = subprocess.run(compile_cmd, capture_output=True, text=True)
+
+            if result.returncode != 0:
+                click.secho("Compilation Error:", fg='red')
+                click.echo(result.stderr)
+            else:
+                # Run
+                run_result = subprocess.run([exe_file], capture_output=True, text=True, timeout=10)
+                if run_result.stdout:
+                    click.echo(run_result.stdout, nl=False)
+                if run_result.stderr:
+                    click.secho(run_result.stderr, fg='red', nl=False)
+                if not run_result.stdout and not run_result.stderr:
+                    click.secho("(no output)", fg='bright_black')
+
+        except subprocess.TimeoutExpired:
+            click.secho("Execution timed out (10s limit)", fg='red')
+        except FileNotFoundError:
+            click.secho("Error: g++ not found. Install a C++ compiler.", fg='red')
+        except Exception as e:
+            click.secho(f"Error: {e}", fg='red')
+        finally:
+            # Cleanup temp files
+            import os
+            try:
+                os.unlink(cpp_file)
+                if os.path.exists(exe_file):
+                    os.unlink(exe_file)
+            except Exception:
+                pass
+
+    click.echo()
+    click.secho("--------------", fg='green')
+
+
+# ============================================================================
+# CSSL - Hidden Command Group
+# ============================================================================
+
+@click.group(hidden=True)
+def cssl():
+    """CSSL scripting commands."""
+    pass
+
+
+@cssl.command(name='exec')
+@click.argument('path', required=False, type=click.Path())
+@click.option('--code', '-c', type=str, help='Execute code directly')
+def cssl_exec(path, code):
+    """Execute CSSL code or file."""
+    from pathlib import Path as PathLib
+
+    try:
+        from ..core.cssl_bridge import CsslLang
+    except ImportError as e:
+        click.secho(f"CSSL runtime not available: {e}", fg='red')
+        return
+
+    cssl_lang = CsslLang()
+
+    # Determine source
+    if code:
+        source = code
+    elif path:
+        path_obj = PathLib(path)
+        if not path_obj.exists():
+            click.secho(f"File not found: {path}", fg='red')
+            return
+        source = path_obj.read_text(encoding='utf-8')
+    else:
+        # Interactive mode
+        click.secho("=== CSSL REPL ===", fg='magenta', bold=True)
+        click.echo("Enter CSSL code. Empty line to execute. CTRL+C to cancel.")
+        click.echo()
+
+        lines = []
+        prompt = 'cssl> '
+
+        try:
+            while True:
+                try:
+                    line = input(prompt)
+                    if not line.strip():
+                        if lines:
+                            break
+                        continue
+                    lines.append(line)
+                except EOFError:
+                    break
+        except KeyboardInterrupt:
+            click.echo()
+            click.secho("Cancelled.", fg='yellow')
+            return
+
+        if not lines:
+            click.secho("No code entered.", fg='yellow')
+            return
+
+        source = '\n'.join(lines)
+
+    # Execute
+    click.secho("--- Output ---", fg='green')
+    try:
+        result = cssl_lang.exec(source)
+
+        # Print output buffer
+        for line in cssl_lang.get_output():
+            click.echo(line)
+
+        if result is not None:
+            click.echo(f"Result: {result}")
+
+    except Exception as e:
+        click.secho(f"CSSL Error: {e}", fg='red')
+
+    click.secho("--------------", fg='green')
+
+
+@cssl.command(name='makemodule')
+@click.argument('path', type=click.Path(exists=True))
+@click.option('--output', '-o', type=click.Path(), help='Output path for .cssl-mod')
+def cssl_makemodule(path, output):
+    """Create a .cssl-mod module from Python/C++ file."""
+    from pathlib import Path as PathLib
+    import pickle
+    import base64
+
+    path_obj = PathLib(path)
+    suffix = path_obj.suffix.lower()
+
+    if suffix not in ('.py', '.cpp', '.cp', '.h'):
+        click.secho(f"Unsupported file type: {suffix}", fg='red')
+        click.echo("Supported: .py, .cpp, .cp, .h")
+        return
+
+    # Read source
+    source = path_obj.read_text(encoding='utf-8')
+
+    # Create module data
+    module_data = {
+        'name': path_obj.stem,
+        'type': 'python' if suffix == '.py' else 'cpp',
+        'source': source,
+        'version': '1.0',
+    }
+
+    # Encode as base64 pickle
+    encoded = base64.b64encode(pickle.dumps(module_data)).decode('utf-8')
+
+    # Write .cssl-mod file
+    out_path = PathLib(output) if output else path_obj.with_suffix('.cssl-mod')
+    out_path.write_text(f"CSSLMOD1\n{encoded}", encoding='utf-8')
+
+    click.secho(f"Created: {out_path}", fg='green')
+    click.echo(f"  Name: {module_data['name']}")
+    click.echo(f"  Type: {module_data['type']}")
+
+
+# Register hidden cssl command group
+cli.add_command(cssl)
+
+
+# ============================================================================
+# Conditional Registration of Experimental Commands
+# ============================================================================
+# AI and CPPY commands are only available when experimental features are enabled
+# Enable via: includecpp settings -> "Enable Experimental Features" checkbox
+
+if _EXPERIMENTAL_ENABLED:
+    cli.add_command(ai)
+    cli.add_command(cppy)
+    cli.add_command(project)
+
+
 if __name__ == '__main__':
     cli()