IncludeCPP 3.7.24__tar.gz → 3.7.26__tar.gz

includecpp-3.7.24/README.md → includecpp-3.7.26/IncludeCPP.egg-info/PKG-INFO

@@ -1,1042 +1,855 @@
-# IncludeCPP
-
-Write C++ code, use it in Python. Auto-generates pybind11 bindings.
-
-```bash
-pip install IncludeCPP
-```
-
-# First Steps
-
-## Project Setup
-
-```bash
-includecpp init
-```
-
-Creates:
-- `cpp.proj` - project configuration
-- `include/` - your C++ source files
-- `plugins/` - generated binding definitions
-
-## Write C++ Code
-
-Put your code in `namespace includecpp`:
-
-```cpp
-// include/fast_list.cpp
-#include <vector>
-
-namespace includecpp {
-
-class FastList {
-public:
-    void append(int val) { data.push_back(val); }
-    int get(int i) { return data[i]; }
-private:
-    std::vector<int> data;
-};
-
-int add(int a, int b) { return a + b; }
-
-}  // namespace includecpp
-```
-
-The parser only scans code inside `namespace includecpp`. Everything else is ignored.
-
-## Generate Bindings
-
-```bash
-includecpp plugin fast_list include/fast_list.cpp
-```
-
-This runs a C++ parser that:
-1. Scans your source files for classes, methods, functions
-2. Extracts signatures, return types, parameter names
-3. Generates `plugins/fast_list.cp` with binding instructions
-
-## Build
-
-```bash
-includecpp rebuild
-```
-
-Compiles your C++ into a Python extension module (`.pyd` on Windows, `.so` on Linux/Mac).
-
-## Use in Python
-
-```python
-from includecpp import fast_list
-
-my_list = fast_list.FastList()
-my_list.append(42)
-print(fast_list.add(1, 2))  # 3
-```
-
-Alternative syntax:
-
-```python
-from includecpp import CppApi
-
-api = CppApi()
-fast_list = api.include("fast_list")
-```
-
-# How to Start
-
-## Minimal Example
-
-```bash
-# 1. Create project
-mkdir myproject && cd myproject
-includecpp init
-
-# 2. Write C++ (include/math.cpp)
-cat > include/math.cpp << 'EOF'
-namespace includecpp {
-    int square(int x) { return x * x; }
-}
-EOF
-
-# 3. Generate plugin
-includecpp plugin math include/math.cpp
-
-# 4. Build
-includecpp rebuild
-
-# 5. Use
-python -c "from includecpp import math; print(math.square(7))"
-```
-
-## Development Workflow
-
-For active development, use `auto`:
-
-```bash
-includecpp auto math
-```
-
-This regenerates the `.cp` file from source and rebuilds in one command.
-
-For fastest iteration:
-
-```bash
-includecpp rebuild --fast
-```
-
-Skips unchanged files. ~0.4s when nothing changed.
-
-# How IncludeCPP Works
-
-## Architecture
-
-```
-Your C++ Source            Plugin File (.cp)           Python Module
-include/math.cpp    --->   plugins/math.cp     --->    math.cpXXX.pyd
-     ^                           ^                          ^
-     |                           |                          |
-  C++ parser              Binding config             pybind11 compiled
-  extracts API            (editable)                 extension
-```
-
-## The Parser
-
-The C++ parser (`parser.cpp`) runs as a compiled executable. It:
-
-1. Tokenizes your C++ source files
-2. Identifies the `namespace includecpp` block
-3. Extracts:
-   - Class names and inheritance
-   - Method signatures (name, return type, parameters)
-   - Function signatures
-   - Template instantiations
-   - Const/static qualifiers
-4. Outputs structured binding instructions to `.cp` files
-
-## Plugin Files (.cp)
-
-The `.cp` format is a declarative binding specification:
-
-```
-SOURCE(math.cpp) math
-
-PUBLIC(
-    math CLASS(Calculator) {
-        CONSTRUCTOR()
-        CONSTRUCTOR(int)
-        METHOD(add)
-        METHOD_CONST(getValue)
-        FIELD(value)
-    }
-
-    math FUNC(square)
-    math TEMPLATE_FUNC(maximum) TYPES(int, float, double)
-)
-```
-
-Key directives:
-- `SOURCE(file.cpp) module_name` - links source to module
-- `PUBLIC(...)` - defines public bindings
-- `CLASS(Name)` - expose a class
-- `STRUCT(Name)` - expose a struct
-- `FUNC(name)` - expose a free function
-- `METHOD(name)` - expose a class method
-- `METHOD_CONST(name, signature)` - for overloaded methods
-- `TEMPLATE_FUNC(name) TYPES(...)` - instantiate template
-- `CONSTRUCTOR(args)` - expose constructor
-- `FIELD(name)` - expose member variable
-- `DEPENDS(mod1, mod2)` - declare module dependencies
-
-## Build System
-
-The build manager:
-
-1. Reads `cpp.proj` configuration
-2. Parses all `.cp` files in `plugins/`
-3. Generates pybind11 binding code
-4. Compiles using CMake with detected compiler (MSVC, GCC, Clang)
-5. Places output in `~/.includecpp/builds/` (not in your project)
-6. Creates a registry so Python can find modules
-
-Caching layers:
-- **Object files**: Only recompile changed `.cpp` files
-- **Generator cache**: Compiler/CMake detection runs once
-- **SHA256 hashes**: Skip unchanged modules entirely
-
-# CLI Reference
-
-Use `includecpp <command> --help` for details.
-
-| Command | Description |
-|---------|-------------|
-| `init` | Create project structure |
-| `plugin <name> <files>` | Generate .cp from C++ sources |
-| `auto <plugin>` | Regenerate .cp and rebuild |
-| `auto --all` | Regenerate and rebuild all plugins |
-| `auto --all -x <name>` | All plugins except specified |
-| `fix <module>` | Analyze C++ code for issues |
-| `fix --all` | Analyze all modules |
-| `fix --undo` | Revert last fix changes |
-| `fix --ai <module>` | AI-enhanced code analysis |
-| `ai key <key>` | Set OpenAI API key |
-| `ai enable` | Enable AI features |
-| `ai disable` | Disable AI features |
-| `ai model --list` | List available models |
-| `ai model set <name>` | Set active model |
-| `ai --info` | Show AI configuration and usage |
-| `ai optimize <module>` | AI code optimization |
-| `ai optimize --agent "<task>"` | Custom AI task |
-| `ai ask "<question>"` | Ask about project with full context |
-| `ai ask "<question>" <module>` | Ask about specific module |
-| `ai edit "<task>"` | Edit code with AI assistance |
-| `ai edit "<task>" --think2` | Thorough edit mode |
-| `ai undo` | Restore files after AI changes |
-| `rebuild` / `build` | Compile all modules |
-| `get <module>` | Show module API (classes, methods, functions) |
-| `install <name>` | Install community module |
-| `update` | Update IncludeCPP |
-| `bug` | Report an issue |
-| `--doc` | Show documentation |
-| `--changelog` | Show latest version changelog |
-| `cppy convert <files> --cpp` | Convert Python to C++ |
-| `cppy convert <files> --py` | Convert C++ to Python |
-| `cppy convert <files> --cpp --no-h` | Convert without header |
-| `cppy convert <files> --cpp --ai` | AI-assisted conversion |
-| `cppy analyze <files>` | Analyze code structure |
-| `cppy types` | Show type mapping tables |
-
-## Build Flags
-
-```bash
-includecpp rebuild                  # Standard build
-includecpp rebuild --clean          # Full rebuild, clear caches
-includecpp rebuild --fast           # Fast incremental (~0.4s if unchanged)
-includecpp rebuild --verbose        # Show compiler output
-includecpp rebuild -m crypto        # Build specific module only
-includecpp rebuild -j 8             # Use 8 parallel jobs
-includecpp rebuild --keep           # Keep generator between builds
-includecpp rebuild --no-incremental # Force full recompilation
-includecpp rebuild --this           # Build current directory as module
-```
-
-## Fast Mode
-
-`--fast` enables object file caching:
-
-| Scenario | Time |
-|----------|------|
-| No changes | ~0.4s |
-| Source changed | ~5-10s |
-| Full rebuild | ~30s |
-
-Clear caches with `--clean`.
-
-## Incompatible Flag Combinations
-
-| Flags | Reason |
-|-------|--------|
-| `--fast` + `--no-incremental` | Fast mode requires incremental |
-| `--fast` + `--clean` | Fast uses caches, clean deletes them |
-| `--fast` + `--this` | Not supported together |
-| `--incremental` + `--no-incremental` | Contradictory |
-
-# Advanced Features
-
-## AI Integration
-
-IncludeCPP integrates with OpenAI for intelligent code analysis and optimization.
-
-### Setup
-
-```bash
-includecpp ai key sk-your-api-key-here
-includecpp ai enable
-```
-
-### Available Models
-
-```bash
-includecpp ai model --list
-```
-
-- `gpt-5` (default) - 256k context
-- `gpt-5-nano` - 32k context, fast
-- `gpt-4o` - 128k context
-- `gpt-4-turbo` - 128k context
-- `gpt-3.5-turbo` - 16k context
-
-### AI-Enhanced Fix
-
-```bash
-includecpp fix --ai mymodule
-includecpp fix --ai --all
-```
-
-Sends source files to AI for analysis, suggests improvements while preserving all existing functions.
-
-### AI Optimize
-
-```bash
-includecpp ai optimize mymodule                        # Optimize module sources
-includecpp ai optimize --file src/utils.cpp            # Optimize specific files
-includecpp ai optimize --agent mymodule "add SIMD"     # Custom task
-```
-
-### AI Ask
-
-Ask questions about your project with full context awareness:
-
-```bash
-includecpp ai ask "where is collision detection?"              # Search all modules
-includecpp ai ask "how does chunk generation work?" chunk_utils  # Specific module
-includecpp ai ask "explain the biome system" --file include/biomes.cpp
-includecpp ai ask "list all public methods" --all -x tests      # All except tests
-```
-
-Supports: module name, --file, --all, -x/--exclude
-
-### AI Edit
-
-Edit code with AI assistance:
-
-```bash
-includecpp ai edit "add logging to all methods" collision
-includecpp ai edit "optimize the loop" --file include/utils.cpp
-includecpp ai edit "add error handling" --all --think2          # Thorough mode
-```
-
-Flags:
-- `--file` - specific files
-- `--all` - all modules
-- `-x/--exclude` - exclude modules
-- `--think2` - thorough analysis (more tokens)
-
-### AI Generate (Super Assistant)
-
-The most powerful AI command - a full assistant with file operations and command execution.
-
-```bash
-# Basic usage
-includecpp ai generate "add error handling to all functions" --file mymodule.cp
-
-# Create new module from scratch
-includecpp ai generate "fast SIMD math library" --t-new-module simd_math
-
-# Planning mode (search, analyze, then execute)
-includecpp ai generate "refactor for better performance" --t-plan --think2
-
-# With Python file (auto-detect module usage)
-includecpp ai generate "update api methods" --file mymod.cp --python main.py
-
-# Full context mode
-includecpp ai generate "comprehensive optimization" --t-max-context --think3
-```
-
-**Flags:**
-| Flag | Description |
-|------|-------------|
-| `--file <path>` | Add files (multiple allowed). .cp files auto-resolve to source |
-| `--think/2/3` | Extended context and planning |
-| `--websearch` | Enable web research |
-| `--t-max-context` | No context reduction |
-| `--t-plan` | Search/grep before executing |
-| `--t-new-module <name>` | Create new module (cpp + plugin + build) |
-| `--python <file.py>` | Include Python file, auto-detect modules |
-| `--confirm` | Skip confirmations |
-
-### AI Tools
-
-List available tools for the generate command:
-
-```bash
-includecpp ai tools
-```
-
-Available tools: READ_FILE, WRITE_FILE, EDIT_FILE, DELETE_FILE, CREATE_FOLDER, LIST_FOLDER, SEARCH_FILES, GREP, RUN_CMD, INCLUDECPP_CMD
-
-### Build Error Analysis
-
-When AI is enabled and `rebuild` fails, the build error is automatically analyzed:
-- Root cause identification
-- Code fix suggestions
-- Prevention tips
-
-### Configuration
-
-```bash
-includecpp ai --info          # Show status, model, usage stats
-includecpp ai disable         # Disable without removing key
-```
-
-API key stored in `~/.includecpp/.secret`.
-
-## Overloaded Methods
-
-Specify the signature to disambiguate:
-
-```
-MODULE CLASS(Circle) {
-    METHOD_CONST(intersects, const Circle&)
-    METHOD_CONST(intersects, const Rect&)
-}
-```
-
-## Template Instantiation
-
-```
-MODULE TEMPLATE_FUNC(maximum) TYPES(int, float, double)
-
-MODULE STRUCT(Point) TYPES(int, float) {
-    FIELD(x)
-    FIELD(y)
-}
-```
-
-Generates `maximum_int`, `maximum_float`, `maximum_double` and `Point_int`, `Point_float`.
-
-## Module Dependencies
-
-```
-DEPENDS(math_utils, geometry)
-```
-
-Ensures dependent modules build first.
-
-## VSCode IntelliSense
-
-Generates `.pyi` stub files for autocomplete. Enable in `cpp.proj`:
-
-```json
-{
-  "CPI-IntelliSense": true
-}
-```
-
-## CPPY Code Conversion
-
-Convert code between Python and C++ with full support for classes, functions, and type hints.
-
-### Python to C++
-
-```bash
-includecpp cppy convert math_utils.py --cpp
-includecpp cppy convert data.py --cpp --no-h  # Skip header
-includecpp cppy convert src/*.py --cpp -o include/
-```
-
-Converts Python code to optimized C++ with:
-- Type hints mapped to C++ types (int, str -> std::string, List -> std::vector)
-- Classes with constructors, methods, fields
-- Functions with proper signatures
-- List comprehensions to STL algorithms
-- Exception handling to try/catch
-
-### C++ to Python
-
-```bash
-includecpp cppy convert utils.cpp --py
-includecpp cppy convert mymodule.cp --py  # Auto-resolve SOURCE()
-```
-
-Converts C++ to Python with:
-- STL types mapped to Python equivalents
-- Classes with type hints
-- Methods become class methods with self
-- Structs become dataclasses
-
-### AI-Assisted Conversion
-
-```bash
-includecpp cppy convert complex_lib.py --cpp --ai
-includecpp cppy convert advanced.cpp --py --ai -v
-```
-
-The `--ai` flag enables intelligent conversion with:
-- Section-by-section analysis and processing
-- Automatic `--think2` context level
-- Comprehensive rulebase for precise conversions
-- pybind11 wrappers for Python features without C++ equivalents:
-  - Generators -> callback pattern / py::iterator
-  - Async/await -> std::async / std::future
-  - Context managers -> RAII pattern
-  - Duck typing -> templates with concepts
-- Reports API changes to user
-- Fallback to standard conversion if AI unavailable
-
-**Workaround Examples:**
-| Python Feature | C++ Workaround |
-|----------------|----------------|
-| `yield` | Callback pattern or py::iterator |
-| `async/await` | std::async + std::future |
-| `with` context | RAII ScopedResource class |
-| List comprehension | transform_to_vector template |
-| Dict comprehension | transform_to_map template |
-| Dynamic attributes | py::object |
-
-### Analyze Code
-
-```bash
-includecpp cppy analyze math.py           # View structure
-includecpp cppy analyze utils.cpp --json  # JSON output
-```
-
-### Type Mapping
-
-```bash
-includecpp cppy types  # Show conversion tables
-```
-
-| Python | C++ |
-|--------|-----|
-| int | int |
-| float | double |
-| str | std::string |
-| bool | bool |
-| List[T] | std::vector<T> |
-| Dict[K,V] | std::unordered_map<K,V> |
-| Optional[T] | std::optional<T> |
-| Tuple[...] | std::tuple<...> |
-
-# Configuration
-
-## cpp.proj
-
-```json
-{
-  "project": "MyProject",
-  "include": "/include",
-  "plugins": "/plugins",
-  "compiler": {
-    "standard": "c++17",
-    "optimization": "O3"
-  }
-}
-```
-
-Options:
-- `project` - project name
-- `include` - C++ source directory
-- `plugins` - plugin file directory
-- `compiler.standard` - C++ standard (c++11, c++14, c++17, c++20)
-- `compiler.optimization` - optimization level (O0, O1, O2, O3)
-
-# Requirements
-
-- Python 3.8+
-- C++ compiler (g++, clang++, MSVC)
-- 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/liliassg/IncludeCPP/issues
-
-# CSSL - C-Style Scripting Language
-
-IncludeCPP includes CSSL, a scripting language with advanced data manipulation features.
-
-## Basic Usage
-
-```python
-from includecpp import CSSL
-
-# Execute CSSL code
-CSSL.exec('''
-    printl("Hello from CSSL!");
-
-    int x = 10;
-    for (i in range(0, 5)) {
-        x = x + i;
-    }
-    printl(x);
-''')
-
-# Execute with arguments
-result = CSSL.exec('''
-    int a = parameter.get(0);
-    int b = parameter.get(1);
-    parameter.return(a + b);
-''', 5, 3)
-print(result)  # 8
-```
-
-## Live Object Sharing
-
-Share Python objects with CSSL scripts. Changes in CSSL reflect back to Python:
-
-```python
-from includecpp import CSSL
-
-class Counter:
-    def __init__(self):
-        self.value = 100
-
-counter = Counter()
-cssl = CSSL.CsslLang()
-cssl.share(counter, "cnt")
-
-# Modify in CSSL - changes reflect in Python!
-cssl.exec('''
-    $cnt.value = $cnt.value - 10;
-    printl($cnt.value);  // 90
-''')
-
-print(counter.value)  # 90 - Changed!
-```
-
-### Shared Object Syntax
-
-- `$name` - Access shared object
-- `$name.property` - Access/modify properties
-- `$name.method()` - Call methods
-- `delete("name")` - Remove shared object
-
-## Data Types
-
-```cssl
-// Basic types
-int x = 42;
-float pi = 3.14;
-string name = "CSSL";
-bool active = true;
-
-// Collections
-array<int> arr;
-arr.push(1);
-arr.push(2);
-printl(arr.length());  // 2
-
-vector<string> vec;
-vec.push("A");
-vec.push("B");
-
-stack<int> s;
-s.push(10);
-s.pop();
-```
-
-## Control Flow
-
-```cssl
-// If/elif/else
-if (x > 10) {
-    printl("big");
-} elif (x > 5) {
-    printl("medium");
-} else {
-    printl("small");
-}
-
-// For loops
-for (i in range(0, 10)) {
-    printl(i);
-}
-
-for (i in range(0, 10, 2)) {  // with step
-    printl(i);  // 0, 2, 4, 6, 8
-}
-
-// Foreach
-array<string> items;
-items.push("A");
-items.push("B");
-foreach (item in items) {
-    printl(item);
-}
-
-// While
-int count = 0;
-while (count < 5) {
-    printl(count);
-    count = count + 1;
-}
-```
-
-## Functions
-
-```cssl
-// Basic function
-void greet(string name) {
-    printl("Hello, " + name + "!");
-}
-
-// Return value
-int add(int a, int b) {
-    return a + b;
-}
-
-// Global variables
-global version = "1.0.0";
-printl(@version);
-
-// r@ syntax for global declaration
-r@myGlobal = "value";
-printl(@myGlobal);
-```
-
-## BruteForce Injection System
-
-CSSL's unique injection operators for data manipulation:
-
-```cssl
-// <== Move data (replaces target)
-target <== source;
-
-// +<== Copy & add to target
-target +<== source;
-
-// -<== Move & remove from source
-target -<== source;
-
-// <<== Code infusion into functions
-myFunc() <<== {
-    printl("Injected code!");
-};
-
-// +<<== Add code without replacing
-myFunc() +<<== {
-    printl("Additional code!");
-};
-```
-
-## String Methods
-
-```cssl
-string s = "Hello World";
-
-// Methods
-s.length();           // 11
-s.toUpper();          // "HELLO WORLD"
-s.toLower();          // "hello world"
-s.contains("World");  // true
-s.startsWith("Hello"); // true
-s.endsWith("World");  // true
-s.replace("World", "CSSL");
-s.split(" ");         // ["Hello", "World"]
-s.trim();             // Remove whitespace
-s.substring(0, 5);    // "Hello"
-```
-
-## CSSL Modules
-
-```python
-# Create callable module
-module = CSSL.module('''
-    string name = parameter.get(0);
-    printl("Hello, " + name + "!");
-''')
-module("World")  # Prints: Hello, World!
-
-# Create module with functions
-math_mod = CSSL.makemodule('''
-    int add(int a, int b) {
-        return a + b;
-    }
-
-    int multiply(int a, int b) {
-        return a * b;
-    }
-''')
-print(math_mod.add(2, 3))       # 5
-print(math_mod.multiply(4, 5))  # 20
-```
-
-## Inline Payloads
-
-```python
-cssl = CSSL.CsslLang()
-
-# Register code as payload
-cssl.code("helpers", '''
-    global version = "1.0.0";
-    void log(string msg) {
-        printl("[LOG] " + msg);
-    }
-''')
-
-# Use in CSSL
-cssl.exec('''
-    payload("helpers");
-    @log("Application started");
-    printl(@version);
-''')
-```
-
-# Changelog
-
-## v3.4.20
-- **Documentation:**
-  - Added complete CSSL language documentation
-  - Live object sharing with `$name` syntax
-  - Data types, control flow, functions, injection system
-  - String methods, modules, and inline payloads
-
-## v3.4.19
-- **Critical Bug Fixes:**
-  - Fixed generator raw string literal in parser.cpp (regex pattern with `)"` prematurely terminated)
-  - Fixed shared object property writes inside loops not persisting to Python
-  - Added member_access handling in flow operations for shared objects
-
-## v3.4.18
-- **Bug Fix:**
-  - Attempted fix for shared object loop writes (partially fixed)
-
-## v3.4.17
-- **New Feature: Live Object Sharing**
-  - `cssl.share(instance, name)` - Share Python objects with CSSL
-  - `$name` syntax for accessing shared objects
-  - Live bidirectional updates - changes in CSSL reflect in Python
-  - `delete("name")` builtin for removing shared objects
-  - Shared object metadata stored in `%APPDATA%/IncludeCPP/shared_objects/`
-
-## v3.4.16
-- **CSSL Bug Fixes:**
-  - Fixed `startsWith()` and `endsWith()` parser errors
-
-## v3.4.15
-- **CSSL Enhancements:**
-  - Added `elif` keyword support
-  - Added `range(start, end, step)` with step parameter
-  - Added `begin()` and `end()` methods to all collection types
-  - Added `cssl.code(name, code)` for inline payload registration
-
-## 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
-  - Added comprehensive try-except handling in `_convert_expr()` with warnings
-  - Improved type inference with empty container handling and exception safety
-  - Complete string escaping: `\0`, `\f`, `\b`, `\a`, `\v` now properly escaped
-- **New Python Constructs:**
-  - Dict comprehensions: `{k: v for k, v in items}` now converts to C++
-  - Set comprehensions: `{x for x in items}` now converts to C++
-  - Generator expressions: `(x for x in items)` now converts to vector
-  - Tuple unpacking: `a, b = func()` now uses C++17 structured bindings
-- **AI Conversion Flags:**
-  - New `--think` flag for less context mode
-  - New `--think3` flag for maximum context mode
-  - New `--websearch` flag for web search in AI conversion
-  - Default: `--think2` mode (unchanged behavior)
-
-## v3.3.10
-- **CPPY Converter seeded RNG fixes:**
-  - Fixed `rng = random.Random(seed)` then `rng.randint()` - now properly tracks seeded RNG variables
-  - Fixed `random.choices(...)[0]` subscript - returns single element directly without `[0]`
-  - Seeded RNG methods (randint, uniform, choice, random) now use the tracked variable with proper C++ distributions
-
-## v3.3.9
-- **CPPY Converter fixes:**
-  - Added f-string (JoinedStr) support - f"text {expr}" now converts to string concatenation
-  - Fixed `random.Random(seed).method()` chained calls - now generates proper inline lambda with seeded RNG
-  - Fixed `random.choices(items, weights=weights)` keyword argument handling
-  - Improved string type detection in f-string expressions
-
-## v3.3.8
-- **Major rulebased converter improvements:**
-  - Added Python `random` module support (randint, uniform, choice, sample, shuffle, gauss, etc.)
-  - Added `os` module support (getcwd, path.join, path.exists, listdir, mkdir, etc.)
-  - Added `time` module support (sleep, time, perf_counter, monotonic)
-  - Added `sys` module support (exit, platform)
-  - Added `math` module support (sqrt, pow, sin, cos, log, etc.)
-  - Added `re` (regex) module support (match, search, sub, findall)
-  - Added `threading` module support (Thread, Lock, Semaphore, etc.)
-  - Added `collections` module support (deque, defaultdict, Counter)
-  - Added `pathlib.Path` support
-- **Unconvertible code detection:**
-  - Automatically detects GUI frameworks (tkinter, PyQt, PySide, pygame) and other unconvertible modules
-  - Shows red warning with line numbers when unconvertible code is found
-  - New `--force` flag to convert anyway (with `/* UNCONVERTIBLE */` comments)
-  - Supports 30+ modules in detection (numpy, pandas, flask, django, etc.)
-- Fixed duplicate file output in `cppy convert --ai`
-- Plugin command now skips inline and underscore-prefixed functions
-
-
----
-
-MIT License | v3.4.20 | [GitHub](https://github.com/liliassg/IncludeCPP)
+Metadata-Version: 2.4
+Name: IncludeCPP
+Version: 3.7.26
+Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
+Home-page: https://github.com/liliassg/IncludeCPP
+Author: Lilias Hatterscheidt
+Author-email: lilias@includecpp.dev
+License: MIT
+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.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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# IncludeCPP
+
+Write C++ code, use it in Python. Auto-generates pybind11 bindings.
+
+```bash
+pip install IncludeCPP
+```
+
+# First Steps
+
+## Project Setup
+
+```bash
+includecpp init
+```
+
+Creates:
+- `cpp.proj` - project configuration
+- `include/` - your C++ source files
+- `plugins/` - generated binding definitions
+
+## Write C++ Code
+
+Put your code in `namespace includecpp`:
+
+```cpp
+// include/fast_list.cpp
+#include <vector>
+
+namespace includecpp {
+
+class FastList {
+public:
+    void append(int val) { data.push_back(val); }
+    int get(int i) { return data[i]; }
+private:
+    std::vector<int> data;
+};
+
+int add(int a, int b) { return a + b; }
+
+}  // namespace includecpp
+```
+
+The parser only scans code inside `namespace includecpp`. Everything else is ignored.
+
+## Generate Bindings
+
+```bash
+includecpp plugin fast_list include/fast_list.cpp
+```
+
+This runs a C++ parser that:
+1. Scans your source files for classes, methods, functions
+2. Extracts signatures, return types, parameter names
+3. Generates `plugins/fast_list.cp` with binding instructions
+
+## Build
+
+```bash
+includecpp rebuild
+```
+
+Compiles your C++ into a Python extension module (`.pyd` on Windows, `.so` on Linux/Mac).
+
+## Use in Python
+
+```python
+from includecpp import fast_list
+
+my_list = fast_list.FastList()
+my_list.append(42)
+print(fast_list.add(1, 2))  # 3
+```
+
+Alternative syntax:
+
+```python
+from includecpp import CppApi
+
+api = CppApi()
+fast_list = api.include("fast_list")
+```
+
+# How to Start
+
+## Minimal Example
+
+```bash
+# 1. Create project
+mkdir myproject && cd myproject
+includecpp init
+
+# 2. Write C++ (include/math.cpp)
+cat > include/math.cpp << 'EOF'
+namespace includecpp {
+    int square(int x) { return x * x; }
+}
+EOF
+
+# 3. Generate plugin
+includecpp plugin math include/math.cpp
+
+# 4. Build
+includecpp rebuild
+
+# 5. Use
+python -c "from includecpp import math; print(math.square(7))"
+```
+
+## Development Workflow
+
+For active development, use `auto`:
+
+```bash
+includecpp auto math
+```
+
+This regenerates the `.cp` file from source and rebuilds in one command.
+
+For fastest iteration:
+
+```bash
+includecpp rebuild --fast
+```
+
+Skips unchanged files. ~0.4s when nothing changed.
+
+# How IncludeCPP Works
+
+## Architecture
+
+```
+Your C++ Source            Plugin File (.cp)           Python Module
+include/math.cpp    --->   plugins/math.cp     --->    math.cpXXX.pyd
+     ^                           ^                          ^
+     |                           |                          |
+  C++ parser              Binding config             pybind11 compiled
+  extracts API            (editable)                 extension
+```
+
+## The Parser
+
+The C++ parser (`parser.cpp`) runs as a compiled executable. It:
+
+1. Tokenizes your C++ source files
+2. Identifies the `namespace includecpp` block
+3. Extracts:
+   - Class names and inheritance
+   - Method signatures (name, return type, parameters)
+   - Function signatures
+   - Template instantiations
+   - Const/static qualifiers
+4. Outputs structured binding instructions to `.cp` files
+
+## Plugin Files (.cp)
+
+The `.cp` format is a declarative binding specification:
+
+```
+SOURCE(math.cpp) math
+
+PUBLIC(
+    math CLASS(Calculator) {
+        CONSTRUCTOR()
+        CONSTRUCTOR(int)
+        METHOD(add)
+        METHOD_CONST(getValue)
+        FIELD(value)
+    }
+
+    math FUNC(square)
+    math TEMPLATE_FUNC(maximum) TYPES(int, float, double)
+)
+```
+
+Key directives:
+- `SOURCE(file.cpp) module_name` - links source to module
+- `PUBLIC(...)` - defines public bindings
+- `CLASS(Name)` - expose a class
+- `STRUCT(Name)` - expose a struct
+- `FUNC(name)` - expose a free function
+- `METHOD(name)` - expose a class method
+- `METHOD_CONST(name, signature)` - for overloaded methods
+- `TEMPLATE_FUNC(name) TYPES(...)` - instantiate template
+- `CONSTRUCTOR(args)` - expose constructor
+- `FIELD(name)` - expose member variable
+- `DEPENDS(mod1, mod2)` - declare module dependencies
+
+## Build System
+
+The build manager:
+
+1. Reads `cpp.proj` configuration
+2. Parses all `.cp` files in `plugins/`
+3. Generates pybind11 binding code
+4. Compiles using CMake with detected compiler (MSVC, GCC, Clang)
+5. Places output in `~/.includecpp/builds/` (not in your project)
+6. Creates a registry so Python can find modules
+
+Caching layers:
+- **Object files**: Only recompile changed `.cpp` files
+- **Generator cache**: Compiler/CMake detection runs once
+- **SHA256 hashes**: Skip unchanged modules entirely
+
+# CLI Reference
+
+Use `includecpp <command> --help` for details.
+
+| Command | Description |
+|---------|-------------|
+| `init` | Create project structure |
+| `plugin <name> <files>` | Generate .cp from C++ sources |
+| `auto <plugin>` | Regenerate .cp and rebuild |
+| `auto --all` | Regenerate and rebuild all plugins |
+| `auto --all -x <name>` | All plugins except specified |
+| `fix <module>` | Analyze C++ code for issues |
+| `fix --all` | Analyze all modules |
+| `fix --undo` | Revert last fix changes |
+| `fix --ai <module>` | AI-enhanced code analysis |
+| `ai key <key>` | Set OpenAI API key |
+| `ai enable` | Enable AI features |
+| `ai disable` | Disable AI features |
+| `ai model --list` | List available models |
+| `ai model set <name>` | Set active model |
+| `ai --info` | Show AI configuration and usage |
+| `ai optimize <module>` | AI code optimization |
+| `ai optimize --agent "<task>"` | Custom AI task |
+| `ai ask "<question>"` | Ask about project with full context |
+| `ai ask "<question>" <module>` | Ask about specific module |
+| `ai edit "<task>"` | Edit code with AI assistance |
+| `ai edit "<task>" --think2` | Thorough edit mode |
+| `ai undo` | Restore files after AI changes |
+| `rebuild` / `build` | Compile all modules |
+| `get <module>` | Show module API (classes, methods, functions) |
+| `install <name>` | Install community module |
+| `update` | Update IncludeCPP |
+| `bug` | Report an issue |
+| `--doc` | Show documentation |
+| `--changelog` | Show latest version changelog |
+| `cppy convert <files> --cpp` | Convert Python to C++ |
+| `cppy convert <files> --py` | Convert C++ to Python |
+| `cppy convert <files> --cpp --no-h` | Convert without header |
+| `cppy convert <files> --cpp --ai` | AI-assisted conversion |
+| `cppy analyze <files>` | Analyze code structure |
+| `cppy types` | Show type mapping tables |
+
+## Build Flags
+
+```bash
+includecpp rebuild                  # Standard build
+includecpp rebuild --clean          # Full rebuild, clear caches
+includecpp rebuild --fast           # Fast incremental (~0.4s if unchanged)
+includecpp rebuild --verbose        # Show compiler output
+includecpp rebuild -m crypto        # Build specific module only
+includecpp rebuild -j 8             # Use 8 parallel jobs
+includecpp rebuild --keep           # Keep generator between builds
+includecpp rebuild --no-incremental # Force full recompilation
+includecpp rebuild --this           # Build current directory as module
+```
+
+## Fast Mode
+
+`--fast` enables object file caching:
+
+| Scenario | Time |
+|----------|------|
+| No changes | ~0.4s |
+| Source changed | ~5-10s |
+| Full rebuild | ~30s |
+
+Clear caches with `--clean`.
+
+## Incompatible Flag Combinations
+
+| Flags | Reason |
+|-------|--------|
+| `--fast` + `--no-incremental` | Fast mode requires incremental |
+| `--fast` + `--clean` | Fast uses caches, clean deletes them |
+| `--fast` + `--this` | Not supported together |
+| `--incremental` + `--no-incremental` | Contradictory |
+
+# Advanced Features
+
+## AI Integration
+
+IncludeCPP integrates with OpenAI for intelligent code analysis and optimization.
+
+### Setup
+
+```bash
+includecpp ai key sk-your-api-key-here
+includecpp ai enable
+```
+
+### Available Models
+
+```bash
+includecpp ai model --list
+```
+
+- `gpt-5` (default) - 256k context
+- `gpt-5-nano` - 32k context, fast
+- `gpt-4o` - 128k context
+- `gpt-4-turbo` - 128k context
+- `gpt-3.5-turbo` - 16k context
+
+### AI-Enhanced Fix
+
+```bash
+includecpp fix --ai mymodule
+includecpp fix --ai --all
+```
+
+Sends source files to AI for analysis, suggests improvements while preserving all existing functions.
+
+### AI Optimize
+
+```bash
+includecpp ai optimize mymodule                        # Optimize module sources
+includecpp ai optimize --file src/utils.cpp            # Optimize specific files
+includecpp ai optimize --agent mymodule "add SIMD"     # Custom task
+```
+
+### AI Ask
+
+Ask questions about your project with full context awareness:
+
+```bash
+includecpp ai ask "where is collision detection?"              # Search all modules
+includecpp ai ask "how does chunk generation work?" chunk_utils  # Specific module
+includecpp ai ask "explain the biome system" --file include/biomes.cpp
+includecpp ai ask "list all public methods" --all -x tests      # All except tests
+```
+
+Supports: module name, --file, --all, -x/--exclude
+
+### AI Edit
+
+Edit code with AI assistance:
+
+```bash
+includecpp ai edit "add logging to all methods" collision
+includecpp ai edit "optimize the loop" --file include/utils.cpp
+includecpp ai edit "add error handling" --all --think2          # Thorough mode
+```
+
+Flags:
+- `--file` - specific files
+- `--all` - all modules
+- `-x/--exclude` - exclude modules
+- `--think2` - thorough analysis (more tokens)
+
+### AI Generate (Super Assistant)
+
+The most powerful AI command - a full assistant with file operations and command execution.
+
+```bash
+# Basic usage
+includecpp ai generate "add error handling to all functions" --file mymodule.cp
+
+# Create new module from scratch
+includecpp ai generate "fast SIMD math library" --t-new-module simd_math
+
+# Planning mode (search, analyze, then execute)
+includecpp ai generate "refactor for better performance" --t-plan --think2
+
+# With Python file (auto-detect module usage)
+includecpp ai generate "update api methods" --file mymod.cp --python main.py
+
+# Full context mode
+includecpp ai generate "comprehensive optimization" --t-max-context --think3
+```
+
+**Flags:**
+| Flag | Description |
+|------|-------------|
+| `--file <path>` | Add files (multiple allowed). .cp files auto-resolve to source |
+| `--think/2/3` | Extended context and planning |
+| `--websearch` | Enable web research |
+| `--t-max-context` | No context reduction |
+| `--t-plan` | Search/grep before executing |
+| `--t-new-module <name>` | Create new module (cpp + plugin + build) |
+| `--python <file.py>` | Include Python file, auto-detect modules |
+| `--confirm` | Skip confirmations |
+
+### AI Tools
+
+List available tools for the generate command:
+
+```bash
+includecpp ai tools
+```
+
+Available tools: READ_FILE, WRITE_FILE, EDIT_FILE, DELETE_FILE, CREATE_FOLDER, LIST_FOLDER, SEARCH_FILES, GREP, RUN_CMD, INCLUDECPP_CMD
+
+### Build Error Analysis
+
+When AI is enabled and `rebuild` fails, the build error is automatically analyzed:
+- Root cause identification
+- Code fix suggestions
+- Prevention tips
+
+### Configuration
+
+```bash
+includecpp ai --info          # Show status, model, usage stats
+includecpp ai disable         # Disable without removing key
+```
+
+API key stored in `~/.includecpp/.secret`.
+
+## Overloaded Methods
+
+Specify the signature to disambiguate:
+
+```
+MODULE CLASS(Circle) {
+    METHOD_CONST(intersects, const Circle&)
+    METHOD_CONST(intersects, const Rect&)
+}
+```
+
+## Template Instantiation
+
+```
+MODULE TEMPLATE_FUNC(maximum) TYPES(int, float, double)
+
+MODULE STRUCT(Point) TYPES(int, float) {
+    FIELD(x)
+    FIELD(y)
+}
+```
+
+Generates `maximum_int`, `maximum_float`, `maximum_double` and `Point_int`, `Point_float`.
+
+## Module Dependencies
+
+```
+DEPENDS(math_utils, geometry)
+```
+
+Ensures dependent modules build first.
+
+## VSCode IntelliSense
+
+Generates `.pyi` stub files for autocomplete. Enable in `cpp.proj`:
+
+```json
+{
+  "CPI-IntelliSense": true
+}
+```
+
+## CPPY Code Conversion
+
+Convert code between Python and C++ with full support for classes, functions, and type hints.
+
+### Python to C++
+
+```bash
+includecpp cppy convert math_utils.py --cpp
+includecpp cppy convert data.py --cpp --no-h  # Skip header
+includecpp cppy convert src/*.py --cpp -o include/
+```
+
+Converts Python code to optimized C++ with:
+- Type hints mapped to C++ types (int, str -> std::string, List -> std::vector)
+- Classes with constructors, methods, fields
+- Functions with proper signatures
+- List comprehensions to STL algorithms
+- Exception handling to try/catch
+
+### C++ to Python
+
+```bash
+includecpp cppy convert utils.cpp --py
+includecpp cppy convert mymodule.cp --py  # Auto-resolve SOURCE()
+```
+
+Converts C++ to Python with:
+- STL types mapped to Python equivalents
+- Classes with type hints
+- Methods become class methods with self
+- Structs become dataclasses
+
+### AI-Assisted Conversion
+
+```bash
+includecpp cppy convert complex_lib.py --cpp --ai
+includecpp cppy convert advanced.cpp --py --ai -v
+```
+
+The `--ai` flag enables intelligent conversion with:
+- Section-by-section analysis and processing
+- Automatic `--think2` context level
+- Comprehensive rulebase for precise conversions
+- pybind11 wrappers for Python features without C++ equivalents:
+  - Generators -> callback pattern / py::iterator
+  - Async/await -> std::async / std::future
+  - Context managers -> RAII pattern
+  - Duck typing -> templates with concepts
+- Reports API changes to user
+- Fallback to standard conversion if AI unavailable
+
+**Workaround Examples:**
+| Python Feature | C++ Workaround |
+|----------------|----------------|
+| `yield` | Callback pattern or py::iterator |
+| `async/await` | std::async + std::future |
+| `with` context | RAII ScopedResource class |
+| List comprehension | transform_to_vector template |
+| Dict comprehension | transform_to_map template |
+| Dynamic attributes | py::object |
+
+### Analyze Code
+
+```bash
+includecpp cppy analyze math.py           # View structure
+includecpp cppy analyze utils.cpp --json  # JSON output
+```
+
+### Type Mapping
+
+```bash
+includecpp cppy types  # Show conversion tables
+```
+
+| Python | C++ |
+|--------|-----|
+| int | int |
+| float | double |
+| str | std::string |
+| bool | bool |
+| List[T] | std::vector<T> |
+| Dict[K,V] | std::unordered_map<K,V> |
+| Optional[T] | std::optional<T> |
+| Tuple[...] | std::tuple<...> |
+
+# Configuration
+
+## cpp.proj
+
+```json
+{
+  "project": "MyProject",
+  "include": "/include",
+  "plugins": "/plugins",
+  "compiler": {
+    "standard": "c++17",
+    "optimization": "O3"
+  }
+}
+```
+
+Options:
+- `project` - project name
+- `include` - C++ source directory
+- `plugins` - plugin file directory
+- `compiler.standard` - C++ standard (c++11, c++14, c++17, c++20)
+- `compiler.optimization` - optimization level (O0, O1, O2, O3)
+
+# Requirements
+
+- Python 3.8+
+- C++ compiler (g++, clang++, MSVC)
+- 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/liliassg/IncludeCPP/issues
+
+# CSSL - C-Style Scripting Language
+
+IncludeCPP includes CSSL, a scripting language with advanced data manipulation features.
+
+## Basic Usage
+
+```python
+from includecpp import CSSL
+
+# Execute CSSL code
+CSSL.exec('''
+    printl("Hello from CSSL!");
+
+    int x = 10;
+    for (i in range(0, 5)) {
+        x = x + i;
+    }
+    printl(x);
+''')
+
+# Execute with arguments
+result = CSSL.exec('''
+    int a = parameter.get(0);
+    int b = parameter.get(1);
+    parameter.return(a + b);
+''', 5, 3)
+print(result)  # 8
+```
+
+## Live Object Sharing
+
+Share Python objects with CSSL scripts. Changes in CSSL reflect back to Python:
+
+```python
+from includecpp import CSSL
+
+class Counter:
+    def __init__(self):
+        self.value = 100
+
+counter = Counter()
+cssl = CSSL.CsslLang()
+cssl.share(counter, "cnt")
+
+# Modify in CSSL - changes reflect in Python!
+cssl.exec('''
+    $cnt.value = $cnt.value - 10;
+    printl($cnt.value);  // 90
+''')
+
+print(counter.value)  # 90 - Changed!
+```
+
+### Shared Object Syntax
+
+- `$name` - Access shared object
+- `$name.property` - Access/modify properties
+- `$name.method()` - Call methods
+- `delete("name")` - Remove shared object
+
+## Data Types
+
+```cssl
+// Basic types
+int x = 42;
+float pi = 3.14;
+string name = "CSSL";
+bool active = true;
+
+// Collections
+array<int> arr;
+arr.push(1);
+arr.push(2);
+printl(arr.length());  // 2
+
+vector<string> vec;
+vec.push("A");
+vec.push("B");
+
+stack<int> s;
+s.push(10);
+s.pop();
+```
+
+## Control Flow
+
+```cssl
+// If/elif/else
+if (x > 10) {
+    printl("big");
+} elif (x > 5) {
+    printl("medium");
+} else {
+    printl("small");
+}
+
+// For loops
+for (i in range(0, 10)) {
+    printl(i);
+}
+
+for (i in range(0, 10, 2)) {  // with step
+    printl(i);  // 0, 2, 4, 6, 8
+}
+
+// Foreach
+array<string> items;
+items.push("A");
+items.push("B");
+foreach (item in items) {
+    printl(item);
+}
+
+// While
+int count = 0;
+while (count < 5) {
+    printl(count);
+    count = count + 1;
+}
+```
+
+## Functions
+
+```cssl
+// Basic function
+void greet(string name) {
+    printl("Hello, " + name + "!");
+}
+
+// Return value
+int add(int a, int b) {
+    return a + b;
+}
+
+// Global variables
+global version = "1.0.0";
+printl(@version);
+
+// r@ syntax for global declaration
+r@myGlobal = "value";
+printl(@myGlobal);
+```
+
+## BruteForce Injection System
+
+CSSL's unique injection operators for data manipulation:
+
+```cssl
+// <== Move data (replaces target)
+target <== source;
+
+// +<== Copy & add to target
+target +<== source;
+
+// -<== Move & remove from source
+target -<== source;
+
+// <<== Code infusion into functions
+myFunc() <<== {
+    printl("Injected code!");
+};
+
+// +<<== Add code without replacing
+myFunc() +<<== {
+    printl("Additional code!");
+};
+```
+
+## String Methods
+
+```cssl
+string s = "Hello World";
+
+// Methods
+s.length();           // 11
+s.toUpper();          // "HELLO WORLD"
+s.toLower();          // "hello world"
+s.contains("World");  // true
+s.startsWith("Hello"); // true
+s.endsWith("World");  // true
+s.replace("World", "CSSL");
+s.split(" ");         // ["Hello", "World"]
+s.trim();             // Remove whitespace
+s.substring(0, 5);    // "Hello"
+```
+
+## CSSL Modules
+
+```python
+# Create callable module
+module = CSSL.module('''
+    string name = parameter.get(0);
+    printl("Hello, " + name + "!");
+''')
+module("World")  # Prints: Hello, World!
+
+# Create module with functions
+math_mod = CSSL.makemodule('''
+    int add(int a, int b) {
+        return a + b;
+    }
+
+    int multiply(int a, int b) {
+        return a * b;
+    }
+''')
+print(math_mod.add(2, 3))       # 5
+print(math_mod.multiply(4, 5))  # 20
+```
+
+## Inline Payloads
+
+```python
+cssl = CSSL.CsslLang()
+
+# Register code as payload
+cssl.script(<name>, "helpers", '''
+    global version = "1.0.0";
+    void log(string msg) {
+        printl("[LOG] " + msg);
+    }
+''')
+
+# Use in CSSL
+cssl.run('''
+    payload("<name>"); // use module you declared in cssl.script(<name>, ...)
+    @log("Application started");
+    printl(@version);
+''')
+```