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

includecpp/core/settings_ui.py

@@ -5,7 +5,8 @@ from pathlib import Path
 try:
     from PyQt6.QtWidgets import (
         QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel,
-        QPushButton, QLineEdit, QCheckBox, QComboBox, QFrame
+        QPushButton, QLineEdit, QCheckBox, QComboBox, QFrame,
+        QScrollArea
     )
     from PyQt6.QtCore import Qt
     from PyQt6.QtGui import QFont
@@ -14,6 +15,18 @@ except ImportError:
     PYQT_AVAILABLE = False
 
 
+def is_experimental_enabled() -> bool:
+    """Check if experimental features are enabled globally."""
+    config_path = Path.home() / '.includecpp' / '.secret'
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text(encoding='utf-8'))
+            return config.get('experimental_features', False)
+        except Exception:
+            pass
+    return False
+
+
 class SettingsWidget(QWidget):
     def __init__(self):
         super().__init__()
@@ -25,24 +38,26 @@ class SettingsWidget(QWidget):
     def _load_config(self):
         if self.config_path.exists():
             try:
-                return json.loads(self.config_path.read_text())
-            except:
+                return json.loads(self.config_path.read_text(encoding='utf-8'))
+            except Exception:
                 pass
         return {}
 
     def _save_config(self):
         self.config_path.parent.mkdir(parents=True, exist_ok=True)
-        self.config_path.write_text(json.dumps(self.config, indent=2))
+        self.config_path.write_text(json.dumps(self.config, indent=2), encoding='utf-8')
 
     def _setup_ui(self):
         self.setWindowTitle('IncludeCPP Settings')
-        self.setFixedSize(340, 520)
+        self.setFixedSize(360, 580)
         self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
 
+        # Main container with background
         main = QWidget(self)
-        main.setGeometry(0, 0, 340, 520)
-        main.setStyleSheet('''
+        main.setGeometry(0, 0, 360, 580)
+
+        base_style = '''
             QWidget {
                 background-color: #1a1a1a;
                 border-radius: 12px;
@@ -51,15 +66,16 @@ class SettingsWidget(QWidget):
             QLabel {
                 color: #e0e0e0;
                 font-size: 12px;
+                background-color: transparent;
             }
             QLineEdit {
                 background-color: #2d2d2d;
                 border: 1px solid #3d3d3d;
                 border-radius: 6px;
-                padding: 10px 12px;
+                padding: 8px 10px;
                 color: #e0e0e0;
-                font-size: 13px;
-                min-height: 18px;
+                font-size: 12px;
+                min-height: 14px;
             }
             QLineEdit:focus {
                 border: 1px solid #4a9eff;
@@ -68,9 +84,9 @@ class SettingsWidget(QWidget):
                 background-color: #2d2d2d;
                 border: 1px solid #3d3d3d;
                 border-radius: 6px;
-                padding: 10px 20px;
+                padding: 8px 16px;
                 color: #e0e0e0;
-                font-size: 13px;
+                font-size: 12px;
             }
             QPushButton:hover {
                 background-color: #3d3d3d;
@@ -80,11 +96,12 @@ class SettingsWidget(QWidget):
             }
             QCheckBox {
                 color: #e0e0e0;
-                font-size: 13px;
+                font-size: 12px;
+                background-color: transparent;
             }
             QCheckBox::indicator {
-                width: 18px;
-                height: 18px;
+                width: 16px;
+                height: 16px;
                 border-radius: 4px;
                 background-color: #2d2d2d;
                 border: 1px solid #3d3d3d;
@@ -96,10 +113,10 @@ class SettingsWidget(QWidget):
                 background-color: #2d2d2d;
                 border: 1px solid #3d3d3d;
                 border-radius: 6px;
-                padding: 10px 12px;
+                padding: 8px 10px;
                 color: #e0e0e0;
-                font-size: 13px;
-                min-height: 18px;
+                font-size: 12px;
+                min-height: 14px;
             }
             QComboBox::drop-down {
                 border: none;
@@ -110,76 +127,131 @@ class SettingsWidget(QWidget):
                 color: #e0e0e0;
                 selection-background-color: #4a9eff;
             }
-        ''')
+            QScrollArea {
+                background-color: transparent;
+                border: none;
+            }
+            QScrollBar:vertical {
+                background-color: #2d2d2d;
+                width: 8px;
+                border-radius: 4px;
+            }
+            QScrollBar::handle:vertical {
+                background-color: #4a4a4a;
+                border-radius: 4px;
+                min-height: 20px;
+            }
+            QScrollBar::handle:vertical:hover {
+                background-color: #5a5a5a;
+            }
+            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
+                height: 0px;
+            }
+        '''
+        main.setStyleSheet(base_style)
 
-        layout = QVBoxLayout(main)
-        layout.setContentsMargins(20, 20, 20, 20)
-        layout.setSpacing(12)
+        # Main layout for the container
+        main_layout = QVBoxLayout(main)
+        main_layout.setContentsMargins(16, 16, 16, 16)
+        main_layout.setSpacing(8)
 
+        # Header (fixed, not scrollable)
         header = QHBoxLayout()
-        title = QLabel('IncludeCPP')
-        title.setFont(QFont('Segoe UI', 14, QFont.Weight.Bold))
-        title.setStyleSheet('color: #4a9eff;')
+        title = QLabel('IncludeCPP Settings')
+        title.setFont(QFont('Segoe UI', 13, QFont.Weight.Bold))
+        title.setStyleSheet('color: #4a9eff; background-color: transparent;')
         header.addWidget(title)
         header.addStretch()
         close_btn = QPushButton('×')
         close_btn.setFixedSize(24, 24)
-        close_btn.setStyleSheet('font-size: 18px; border-radius: 12px;')
+        close_btn.setStyleSheet('font-size: 16px; border-radius: 12px;')
         close_btn.clicked.connect(self.close)
         header.addWidget(close_btn)
-        layout.addLayout(header)
+        main_layout.addLayout(header)
+
+        self._add_separator(main_layout)
 
-        self._add_separator(layout)
+        # Scroll area for content
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        scroll.setStyleSheet('QScrollArea { background-color: transparent; border: none; }')
 
+        # Content widget inside scroll area
+        content = QWidget()
+        content.setStyleSheet('background-color: transparent;')
+        content_layout = QVBoxLayout(content)
+        content_layout.setContentsMargins(0, 0, 8, 0)
+        content_layout.setSpacing(10)
+
+        # --- Experimental Features Section ---
+        exp_label = QLabel('Experimental')
+        exp_label.setFont(QFont('Segoe UI', 10, QFont.Weight.Bold))
+        exp_label.setStyleSheet('color: #ff9800; background-color: transparent;')
+        content_layout.addWidget(exp_label)
+
+        self.experimental_enabled = QCheckBox('Enable Experimental Features')
+        self.experimental_enabled.setToolTip('Enables AI and CPPY commands (may contain bugs)')
+        content_layout.addWidget(self.experimental_enabled)
+
+        self._add_separator(content_layout)
+
+        # --- AI Configuration Section ---
         ai_label = QLabel('AI Configuration')
-        ai_label.setFont(QFont('Segoe UI', 11, QFont.Weight.Bold))
-        layout.addWidget(ai_label)
+        ai_label.setFont(QFont('Segoe UI', 10, QFont.Weight.Bold))
+        content_layout.addWidget(ai_label)
 
         self.ai_enabled = QCheckBox('Enable AI Features')
-        layout.addWidget(self.ai_enabled)
+        content_layout.addWidget(self.ai_enabled)
 
-        layout.addWidget(QLabel('OpenAI API Key'))
+        content_layout.addWidget(QLabel('OpenAI API Key'))
         self.api_key = QLineEdit()
         self.api_key.setEchoMode(QLineEdit.EchoMode.Password)
         self.api_key.setPlaceholderText('sk-...')
-        layout.addWidget(self.api_key)
+        content_layout.addWidget(self.api_key)
 
-        layout.addWidget(QLabel('Model'))
+        content_layout.addWidget(QLabel('Model'))
         self.model = QComboBox()
         self.model.addItems(['gpt-5', 'gpt-5-nano', 'gpt-4o', 'gpt-4-turbo', 'gpt-3.5-turbo'])
-        layout.addWidget(self.model)
+        content_layout.addWidget(self.model)
 
-        self._add_separator(layout)
+        self._add_separator(content_layout)
 
+        # --- API Tokens Section ---
         tokens_label = QLabel('API Tokens')
-        tokens_label.setFont(QFont('Segoe UI', 11, QFont.Weight.Bold))
-        layout.addWidget(tokens_label)
+        tokens_label.setFont(QFont('Segoe UI', 10, QFont.Weight.Bold))
+        content_layout.addWidget(tokens_label)
 
-        layout.addWidget(QLabel('Brave Search API'))
+        content_layout.addWidget(QLabel('Brave Search API'))
         self.brave_key = QLineEdit()
         self.brave_key.setEchoMode(QLineEdit.EchoMode.Password)
         self.brave_key.setPlaceholderText('Token for --websearch')
-        layout.addWidget(self.brave_key)
+        content_layout.addWidget(self.brave_key)
 
-        self._add_separator(layout)
+        self._add_separator(content_layout)
 
+        # --- Usage Limits Section ---
         limits_label = QLabel('Usage Limits')
-        limits_label.setFont(QFont('Segoe UI', 11, QFont.Weight.Bold))
-        layout.addWidget(limits_label)
+        limits_label.setFont(QFont('Segoe UI', 10, QFont.Weight.Bold))
+        content_layout.addWidget(limits_label)
 
-        layout.addWidget(QLabel('Daily Token Limit'))
+        content_layout.addWidget(QLabel('Daily Token Limit'))
         self.daily_limit = QLineEdit()
         self.daily_limit.setPlaceholderText('220000')
-        layout.addWidget(self.daily_limit)
+        content_layout.addWidget(self.daily_limit)
+
+        content_layout.addStretch()
 
-        layout.addStretch()
+        scroll.setWidget(content)
+        main_layout.addWidget(scroll)
 
+        # Save button (fixed at bottom)
         btn_layout = QHBoxLayout()
         save_btn = QPushButton('Save')
-        save_btn.setStyleSheet('background-color: #4a9eff;')
+        save_btn.setStyleSheet('background-color: #4a9eff; font-weight: bold;')
         save_btn.clicked.connect(self._save)
         btn_layout.addWidget(save_btn)
-        layout.addLayout(btn_layout)
+        main_layout.addLayout(btn_layout)
 
         self._drag_pos = None
 
@@ -190,6 +262,9 @@ class SettingsWidget(QWidget):
         layout.addWidget(line)
 
     def _load_values(self):
+        # Experimental features
+        self.experimental_enabled.setChecked(self.config.get('experimental_features', False))
+        # AI settings
         self.ai_enabled.setChecked(self.config.get('enabled', False))
         api = self.config.get('api_key', '')
         if api:
@@ -205,10 +280,14 @@ class SettingsWidget(QWidget):
         self.daily_limit.setText(str(daily_limit))
 
     def _save(self):
+        # Experimental features
+        self.config['experimental_features'] = self.experimental_enabled.isChecked()
+        # AI settings
         self.config['enabled'] = self.ai_enabled.isChecked()
         api = self.api_key.text().strip()
         if api:
             self.config['api_key'] = api
+        # Only update model if user explicitly changed it (preserve existing if combo unchanged)
         self.config['model'] = self.model.currentText()
         brave = self.brave_key.text().strip()
         if brave:

includecpp/generator/parser.cpp

@@ -8,6 +8,7 @@
 #include <functional>
 #include <filesystem>
 #include <iterator>
+#include <set>
 
 int API::main(int argc, char* argv[]) {
     if (argc < 5) {
@@ -489,6 +490,27 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                                             sig.param_types.push_back(parts[i]);
                                         }
 
+                                        // v3.3.22: Also populate parameters for display in get command
+                                        for (size_t i = 0; i < sig.param_types.size(); ++i) {
+                                            ParameterInfo param;
+                                            std::string type_str = sig.param_types[i];
+                                            param.type = type_str;
+                                            param.name = "arg" + std::to_string(i + 1);
+                                            // Check for const
+                                            if (type_str.find("const ") != std::string::npos) {
+                                                param.is_const = true;
+                                            }
+                                            // Check for reference
+                                            if (!type_str.empty() && type_str.back() == '&') {
+                                                param.is_reference = true;
+                                            }
+                                            // Check for pointer
+                                            if (!type_str.empty() && type_str.back() == '*') {
+                                                param.is_pointer = true;
+                                            }
+                                            sig.parameters.push_back(param);
+                                        }
+
                                         cb.method_signatures.push_back(sig);
                                         // Also add to legacy methods list for backward compatibility
                                         cb.methods.push_back(sig.name);
@@ -678,6 +700,47 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
         validate_namespace_includecpp(desc.source_path, desc.module_name);
     }
 
+    // v3.4.1: Auto-detect header from #include directives in source file
+    if (!desc.has_header && !desc.source_path.empty()) {
+        std::ifstream source_file(desc.source_path);
+        if (source_file.is_open()) {
+            std::string line;
+            std::regex include_regex(R"(^\s*#include\s*"([^"]+\.h(?:pp)?)")");
+            std::smatch match;
+
+            while (std::getline(source_file, line)) {
+                if (std::regex_search(line, match, include_regex)) {
+                    std::string header_name = match[1].str();
+                    // Skip standard headers and pybind11 headers
+                    if (header_name.find("pybind11") == std::string::npos &&
+                        header_name.find("std") == std::string::npos) {
+                        // Found a local header - construct the path
+                        std::filesystem::path source_path(desc.source_path);
+                        std::filesystem::path header_path = source_path.parent_path() / header_name;
+
+                        // Check if the header file exists
+                        if (std::filesystem::exists(header_path)) {
+                            desc.header_path = header_path.string();
+                            desc.has_header = true;
+                            std::cout << "NOTE: Auto-detected header for '" << desc.module_name
+                                      << "': " << desc.header_path << std::endl;
+                            break;
+                        }
+                        // Also try in include/ subdirectory
+                        header_path = source_path.parent_path().parent_path() / "include" / header_name;
+                        if (std::filesystem::exists(header_path)) {
+                            desc.header_path = header_path.string();
+                            desc.has_header = true;
+                            std::cout << "NOTE: Auto-detected header for '" << desc.module_name
+                                      << "': " << desc.header_path << std::endl;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     return desc;
 }
 
@@ -901,6 +964,11 @@ std::string API::generate_pybind11_code(const std::vector<ModuleDescriptor>& mod
     code << "#include <pybind11/complex.h>\n";
     code << "#include <pybind11/chrono.h>\n\n";
 
+    // v3.3.22: Track included headers to prevent duplicates
+    std::set<std::string> included_headers;
+    std::vector<std::string> ordered_includes;
+
+    // First pass: collect all headers and detect dependencies
     for (const auto& mod : modules) {
         std::string include_path;
         if (mod.has_header) {
@@ -912,6 +980,19 @@ std::string API::generate_pybind11_code(const std::vector<ModuleDescriptor>& mod
                       << "' has no separate header, including source file: "
                       << include_path << std::endl;
         }
+
+        // Skip if already included
+        if (included_headers.find(include_path) != included_headers.end()) {
+            std::cout << "NOTE: Skipping duplicate include: " << include_path << std::endl;
+            continue;
+        }
+
+        included_headers.insert(include_path);
+        ordered_includes.push_back(include_path);
+    }
+
+    // Generate includes (duplicates already filtered)
+    for (const auto& include_path : ordered_includes) {
         code << "#include \"" << include_path << "\"\n";
     }
 

{includecpp-3.3.11.dist-info → includecpp-3.4.2.dist-info}/METADATA

@@ -1,25 +1,22 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.3.11
+Version: 3.4.2
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
-Home-page: https://github.com/includecpp/includecpp
-Author: IncludeCPP Team
-Author-email: IncludeCPP Team <contact@includecpp.dev>
+Home-page: https://github.com/liliassg/IncludeCPP
+Author: Lilias Hatterscheidt
+Author-email: lilias@includecpp.dev
 License: MIT
-Project-URL: Homepage, https://github.com/includecpp/includecpp
-Project-URL: Documentation, https://includecpp.readthedocs.io
-Project-URL: Repository, https://github.com/includecpp/includecpp
-Project-URL: Bug Tracker, https://github.com/includecpp/includecpp/issues
+Project-URL: Repository, https://github.com/liliassg/IncludeCPP
+Project-URL: Bug Tracker, https://github.com/liliasg/IncludeCPP/issues
 Keywords: c++,python,bindings,pybind11,template,performance,threading
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: C++
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -30,7 +27,7 @@ Requires-Dist: pybind11>=2.11.0
 Requires-Dist: click>=8.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: requests>=2.28.0
-Dynamic: author
+Dynamic: author-email
 Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
@@ -604,8 +601,159 @@ Options:
 - pybind11 (installed automatically)
 - CMake (for build generation)
 
+# Experimental Features
+
+The following features are **experimental** and may contain bugs:
+
+- `includecpp ai` - AI-powered code assistance
+- `includecpp cppy` - Python to C++ code conversion
+
+These commands are **hidden by default**. To enable them:
+
+```bash
+includecpp settings
+```
+
+Then check **"Enable Experimental Features"** and save.
+
+**Warning:** Experimental features are under active development and may:
+- Produce incorrect output
+- Have breaking changes between versions
+- Be removed or significantly changed
+
+Use at your own discretion. Report issues at: https://github.com/hatte/IncludeCPP/issues
+
 # Changelog
 
+## v3.4.2
+- **New Feature: `exec` Command**
+  - Interactive REPL for quick code testing without creating files
+  - `includecpp exec py` - Python REPL with IncludeCPP support
+  - `includecpp exec cpp` - C++ REPL with auto-compilation
+  - Auto-import modules: `includecpp exec py mymodule`
+  - Auto-import from plugins: `includecpp exec py plugins/math.cp`
+  - Import all modules: `includecpp exec py --all`
+  - Enter code line by line, press ENTER on empty line to execute
+
+## v3.4.1
+- **Bug Fixes:**
+  - fix command: Fixed false positives for unused variables (sum, memory_) using word-boundary matching
+  - CPPY: C++ reserved words (double, int, void, etc.) now properly escaped as Python identifiers
+  - CPPY: C++ STL functions (accumulate, find, sort, reverse) properly converted to Python equivalents
+  - CPPY: Member variables with trailing underscore (memory_) now get self. prefix
+  - CPPY: Private class members now detected for self. prefix conversion
+  - Plugin: Auto-detect header files from #include directives in source files
+
+## v3.4.0
+- **CodeMaker Major Update:**
+  - New Source node type with 8 connection ports for code generation
+  - Smart code generation: Source nodes generate Python/Plugin files with all connected nodes included
+  - Right-click on Source node: "Create Python" creates .py in project root
+  - Right-click on Source node: "Create Plugin" creates .cp, .h, .cpp in plugins/ and include/
+  - Code options hidden after file generation (prevents duplicates)
+  - Enhanced description display with background rect in node body
+  - Arrow key navigation to pan the canvas
+  - New toolbar buttons: Align H, Align V, Auto-Arrange
+  - Quick-add buttons: +Source, +Class, +Function
+  - Properties Panel on the right side for editing selected nodes
+  - Auto-arrange algorithm for grid layout
+  - Align horizontal/vertical for selected nodes
+- **Bug Fixes:**
+  - Changelog encoding fixes for Windows console
+  - CPPY C++ keyword escaping (double, int, etc.)
+  - CPPY C++ to Python syntax conversion improvements
+  - CPPY self. prefix for member variables
+  - Plugin auto-header detection from #include
+
+## v3.3.21
+- **Encoding Fixes:**
+  - Replaced Unicode arrow characters with ASCII in changelog (Windows console compatibility)
+
+## v3.3.20
+- **Bug Fixes:**
+  - Fixed `QPoint.toPoint()` AttributeError in rubber band selection
+  - Added UTF-8 encoding to all file read/write operations for cross-platform compatibility
+  - Fixed bare `except:` clauses to proper `except Exception:` in settings_ui.py
+
+## v3.3.19
+- **PyQt6 Import Fix:**
+  - Fixed silent import failure that caused "PyQt6 not installed" error even when installed
+  - Moved `QUndoStack`, `QUndoCommand`, `QShortcut` from QtWidgets to QtGui (correct location in PyQt6)
+
+## v3.3.18
+- **CodeMaker Visual Editor (Experimental):**
+  - Complete rewrite of `project` command with professional-grade UI
+  - 24 node types across 5 categories (Code Structures, Functions, Data, Organization, Flow)
+  - Undo/redo system with full command history
+  - Multi-selection with rubber band and Ctrl+Click
+  - Copy/paste/duplicate with Ctrl+C/V/D shortcuts
+  - Node grouping with Ctrl+G
+  - Code generation for C++ (header/source) and Python
+  - Search and filter nodes by name and type
+  - Export to PNG/SVG with transparency support
+  - Categorized right-click context menus
+  - Toolbar with common actions
+  - Cross-platform font detection (Windows/macOS/Linux)
+  - DPI-aware scaling for high-resolution displays
+- **Experimental Feature Gating:**
+  - `project` command now requires "Enable Experimental Features" in settings
+  - Consistent gating with `ai` and `cppy` commands
+
+## v3.3.16-3.3.17
+- **QPen Bug Fixes:**
+  - Fixed 3 instances of `setPen(Qt.PenStyle.NoPen)` to `setPen(QPen(Qt.PenStyle.NoPen))`
+  - Proper QPen construction for PyQt6 compatibility
+
+## v3.3.15
+- **CPPY Converter Major Fixes:**
+  - Functions returning container now get `std::vector<T>` return type (e.g., shuffle_list)
+  - `max(items)` / `min(items)` now correctly uses `std::max_element` / `std::min_element`
+  - Template element parameters (`value`, `item`) now use `const T&` instead of `double`
+  - Explicit template instantiations now include correct return types and all parameters
+  - Python docstrings now become C++ comments instead of dangling string literals
+- **Unicode Fallback System:**
+  - AI progress indicators use ASCII fallbacks on Windows terminals
+  - Fixed encoding errors in changelog display
+
+## v3.3.14
+- **Experimental Features System:**
+  - AI and CPPY commands now hidden by default
+  - Enable via Settings UI: "Enable Experimental Features" checkbox
+  - Warning about potential bugs documented in README
+- **Settings UI Improvements:**
+  - Added scrollable content area to prevent layout squashing
+  - New "Experimental" section with orange header
+  - Better spacing and styling for all elements
+  - Preserved existing config values on save
+
+## v3.3.13
+- **Template Support for Generic Functions:**
+  - Generic container parameters now generate proper C++ templates
+  - `template<typename T> T getChoice(const std::vector<T>& choices)` instead of invalid `std::vector<auto>`
+  - Automatic explicit template instantiations for int, double, std::string
+- **AI Conversion - No pybind11:**
+  - AI no longer generates pybind11 code - IncludeCPP handles bindings automatically
+  - Clean C++ output in `namespace includecpp`
+  - User runs `includecpp plugin` separately to generate bindings
+- **AI Context - Dynamic README:**
+  - AI now loads README.md dynamically for accurate IncludeCPP documentation
+  - Better understanding of IncludeCPP workflow and patterns
+
+## v3.3.12
+- **Smart Type Inference:**
+  - Parameter types now inferred from common naming patterns (start/end -> int, name/path -> string, etc.)
+  - Variable type tracking throughout conversion for accurate string detection
+  - Loop variable types inferred from iterables (enumerate, for loops)
+- **String Conversion Fix:**
+  - No more `std::to_string()` on already-string variables in f-strings
+  - `_is_string_expr()` method for comprehensive string type detection
+  - String variables detected by name, type tracking, and method calls
+- **AI Conversion Improvements:**
+  - Explicit file extension enforcement (.cpp NOT .cp, .h NOT .hpp)
+  - Better --no-h flag handling with clear AI instructions
+  - AI can request clarification on unconvertible modules (tkinter, pygame, etc.)
+  - User prompted for input when AI needs guidance
+
 ## v3.3.11
 - **CPPY Converter Improvements:**
   - Added `_safe_arg()` and `_safe_get()` for robust bounds checking on all args
@@ -655,13 +803,7 @@ Options:
 - Fixed duplicate file output in `cppy convert --ai`
 - Plugin command now skips inline and underscore-prefixed functions
 
-## v3.3.7
-- Fixed AI knowledge: Now properly documents `SOURCE() && HEADER()` syntax for .cp files
-- AI generates correct .cp format with `&& HEADER()` when creating both .cpp and .h files
-- `cppy convert --ai --no-h` now properly instructs AI to skip header generation
-- Fixed verbose output error in changes_summary method
-
 
 ---
 
-MIT License | v3.3.11 | [GitHub](https://github.com/liliassg/IncludeCPP)
+MIT License | v3.4.2 | [GitHub](https://github.com/liliassg/IncludeCPP)