IncludeCPP 3.7.1__py3-none-any.whl → 3.7.25__py3-none-any.whl

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.7.0"
+__version__ = "3.7.25"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/__init__.pyi

@@ -13,7 +13,7 @@ except ImportError:
     pass  # Generated during rebuild
 
 
-# ========== CSSL Module - CSO Service Script Language ==========
+# ========== CSSL Module ==========
 class _CSSLModule:
     """CSSL callable module created via CSSL.module()"""
     def __call__(self, *args: Any) -> Any:
@@ -139,7 +139,7 @@ class _CSSLBridge:
         ...
 
 
-# CSSL module instance - CSO Service Script Language
+# CSSL module instance
 CSSL: _CSSLBridge
 
 __version__: str

includecpp/cli/commands.py

@@ -1193,7 +1193,7 @@ def build(ctx, clean, keep, verbose, no_incremental, incremental, parallel, jobs
 @cli.command()
 @click.argument('module_name')
 def add(module_name):
-    """Create a new module template."""
+    """Create a new module template with sample C++ code."""
     plugins_dir = Path("plugins")
     if not plugins_dir.exists():
         click.echo("Error: plugins/ directory not found")
@@ -1204,6 +1204,7 @@ def add(module_name):
         click.echo(f"Module {module_name} already exists")
         return
 
+    # Create .cp config file
     template = f"""SOURCE(include/{module_name}.cpp) {module_name}
 
 PUBLIC(
@@ -1215,7 +1216,41 @@ PUBLIC(
         f.write(template)
 
     click.echo(f"Created {cp_file}")
-    click.echo(f"Now create include/{module_name}.cpp with your C++ code")
+
+    # Create include/ directory if it doesn't exist
+    include_dir = Path("include")
+    include_dir.mkdir(exist_ok=True)
+
+    # Create .cpp file with sample code
+    cpp_file = include_dir / f"{module_name}.cpp"
+    if not cpp_file.exists():
+        cpp_template = f"""#include <string>
+#include <vector>
+
+namespace includecpp {{
+
+// Example function - returns a greeting
+std::string example_function(const std::string& name) {{
+    return "Hello, " + name + "!";
+}}
+
+// Add more functions here...
+// int add(int a, int b) {{ return a + b; }}
+// std::vector<int> range(int n) {{ ... }}
+
+}} // namespace includecpp
+"""
+        with open(cpp_file, 'w', encoding='utf-8') as f:
+            f.write(cpp_template)
+
+        click.echo(f"Created {cpp_file}")
+    else:
+        click.echo(f"Note: {cpp_file} already exists, skipped")
+
+    click.echo(f"\nNext steps:")
+    click.echo(f"  1. Edit include/{module_name}.cpp to add your functions")
+    click.echo(f"  2. Update plugins/{module_name}.cp to expose functions")
+    click.echo(f"  3. Run: includecpp rebuild")
 
 @cli.command('list')
 def list_modules():
@@ -7480,13 +7515,12 @@ def cssl_exec(path, code):
     # Execute
     click.secho("--- Output ---", fg='green')
     try:
-        result = cssl_lang.exec(source)
+        result = cssl_lang.run(source)
 
         # Output is already printed to stdout during execution via runtime.output()
-        # No need to print buffer again - this was causing double output
-
-        if result is not None:
-            click.echo(f"Result: {result}")
+        # Don't print "Result:" automatically - users should use printl() for output
+        # This prevents unwanted output for function calls like: Function();
+        pass
 
     except Exception as e:
         click.secho(f"CSSL Error: {e}", fg='red')
@@ -7535,10 +7569,29 @@ def cssl_makemodule(path, output):
 
 
 @cssl.command(name='doc')
-def cssl_doc():
-    """Show CSSL documentation."""
+@click.argument('search', required=False, default=None)
+@click.option('--list', '-l', 'list_sections', is_flag=True, help='List all documentation sections')
+def cssl_doc(search, list_sections):
+    """Show CSSL documentation.
+
+    \b
+    Usage:
+      includecpp cssl doc              # Show full documentation
+      includecpp cssl doc "open"       # Search for 'open' keyword
+      includecpp cssl doc "$"          # Search for shared variable syntax
+      includecpp cssl doc "define"     # Search for define keyword
+      includecpp cssl doc --list       # List all sections
+
+    \b
+    Examples:
+      includecpp cssl doc "class"      # Show OOP/class documentation
+      includecpp cssl doc "json::"     # Show JSON functions
+      includecpp cssl doc "this->"     # Show this-> keyword usage
+      includecpp cssl doc "map"        # Show Map container docs
+    """
     from pathlib import Path as PathLib
     import os
+    import re
 
     # Find the documentation file in the cssl package directory
     cssl_dir = PathLib(__file__).parent.parent / 'core' / 'cssl'
@@ -7558,8 +7611,122 @@ def cssl_doc():
 
     if doc_path.exists():
         content = doc_path.read_text(encoding='utf-8')
-        # Use pager for long content
-        click.echo_via_pager(content)
+
+        # List sections mode
+        if list_sections:
+            click.secho("CSSL Documentation Sections", fg='cyan', bold=True)
+            click.secho("=" * 40, fg='cyan')
+            sections = re.findall(r'^##\s+(.+)$', content, re.MULTILINE)
+            for i, section in enumerate(sections, 1):
+                click.echo(f"  {i:2d}. {section}")
+            click.echo()
+            click.echo("Use: includecpp cssl doc \"<keyword>\" to search")
+            return
+
+        # Search mode
+        if search:
+            click.secho(f"Searching for: '{search}'", fg='cyan', bold=True)
+            click.secho("=" * 50, fg='cyan')
+            click.echo()
+
+            # Split into subsections (### headers) for focused results
+            subsections = re.split(r'(?=^### )', content, flags=re.MULTILINE)
+
+            # Also split into main sections (## headers)
+            main_sections = re.split(r'(?=^## )', content, flags=re.MULTILINE)
+
+            # Find matching subsections (### level) - most focused
+            matching_subsections = []
+            for subsection in subsections:
+                if search.lower() in subsection.lower():
+                    # Extract title
+                    title_match = re.match(r'^###\s+(.+)$', subsection, re.MULTILINE)
+                    if title_match:
+                        # Trim subsection to just the content until next ### or ##
+                        lines = subsection.split('\n')
+                        trimmed_lines = []
+                        for line in lines:
+                            if line.startswith('## ') and not line.startswith('### '):
+                                break
+                            trimmed_lines.append(line)
+                        matching_subsections.append((title_match.group(1), '\n'.join(trimmed_lines)))
+
+            if matching_subsections:
+                click.secho(f"Found {len(matching_subsections)} matching subsection(s):", fg='green')
+                click.echo()
+
+                # Show focused subsections (limit output)
+                for title, sub_content in matching_subsections[:5]:
+                    click.secho(f"### {title}", fg='yellow', bold=True)
+                    # Highlight search term in content
+                    highlighted = re.sub(
+                        f'({re.escape(search)})',
+                        click.style(r'\1', fg='green', bold=True),
+                        sub_content,
+                        flags=re.IGNORECASE
+                    )
+                    # Limit lines per subsection
+                    lines = highlighted.split('\n')
+                    if len(lines) > 30:
+                        click.echo('\n'.join(lines[:30]))
+                        click.secho(f"  ... ({len(lines) - 30} more lines)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                    click.echo()
+                    click.secho("-" * 40, fg='cyan')
+                    click.echo()
+
+                if len(matching_subsections) > 5:
+                    click.secho(f"... and {len(matching_subsections) - 5} more subsections", fg='cyan')
+                    click.echo("Use --list to see all sections")
+            else:
+                # Fall back to main section search (## level)
+                found_sections = []
+                for section in main_sections:
+                    if search.lower() in section.lower():
+                        title_match = re.match(r'^##\s+(.+)$', section, re.MULTILINE)
+                        if title_match:
+                            found_sections.append((title_match.group(1), section))
+
+                if found_sections:
+                    click.secho(f"Found in {len(found_sections)} section(s):", fg='green')
+                    for title, _ in found_sections:
+                        click.echo(f"  - {title}")
+                    click.echo()
+
+                    # Show first matching section, trimmed
+                    title, section = found_sections[0]
+                    click.secho(f"## {title}", fg='yellow', bold=True)
+                    highlighted = re.sub(
+                        f'({re.escape(search)})',
+                        click.style(r'\1', fg='green', bold=True),
+                        section,
+                        flags=re.IGNORECASE
+                    )
+                    lines = highlighted.split('\n')
+                    if len(lines) > 40:
+                        click.echo('\n'.join(lines[:40]))
+                        click.secho(f"\n... ({len(lines) - 40} more lines in this section)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                else:
+                    click.secho(f"No matches found for '{search}'", fg='yellow')
+                    click.echo()
+                    click.echo("Try searching for:")
+                    click.echo("  - Keywords: class, function, define, open, global, shuffled")
+                    click.echo("  - Syntax: $, @, ::, this->, <<==, <==, #$")
+                    click.echo("  - Types: string, int, stack, vector, map, json")
+                    click.echo()
+                    click.echo("Or use: includecpp cssl doc --list")
+        else:
+            # Full documentation mode
+            # Replace Unicode characters that may not be supported on all terminals
+            safe_content = content.replace('✓', '[OK]').replace('✗', '[X]').replace('→', '->').replace('←', '<-').replace('•', '*').replace('─', '-').replace('│', '|').replace('└', '+').replace('├', '+').replace('▸', '>').replace('▾', 'v')
+            try:
+                click.echo_via_pager(safe_content)
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace'
+                click.echo(safe_content.encode('ascii', errors='replace').decode('ascii'))
     else:
         click.secho("Documentation file not found.", fg='yellow')
         click.echo("Looking for: CSSL_DOCUMENTATION.md")
@@ -7697,26 +7864,46 @@ def cssl_vscode():
         click.secho("CSSL extension files not found in package.", fg='red')
         return
 
-    # Install extension
-    target_dir = vscode_ext_dir / 'includecpp.cssl-1.0.0'
+    # Get version from package.json
+    pkg_json = source_ext_dir / 'package.json'
+    current_version = "1.1.0"
+    if pkg_json.exists():
+        try:
+            pkg_data = json.loads(pkg_json.read_text(encoding='utf-8'))
+            current_version = pkg_data.get('version', '1.1.0')
+        except:
+            pass
+
+    target_dir = vscode_ext_dir / f'includecpp.cssl-{current_version}'
 
     try:
+        # Check for existing installations
+        existing_version = None
+        for existing in vscode_ext_dir.glob('includecpp.cssl-*'):
+            existing_version = existing.name.split('-')[-1]
+            if existing_version != current_version:
+                click.echo(f"Removing old version: {existing_version}")
+                shutil.rmtree(existing)
+
         if target_dir.exists():
             shutil.rmtree(target_dir)
 
         shutil.copytree(source_ext_dir, target_dir)
 
-        click.secho("CSSL VSCode extension installed!", fg='green', bold=True)
+        if existing_version and existing_version != current_version:
+            click.secho(f"CSSL extension updated: v{existing_version} -> v{current_version}", fg='green', bold=True)
+        else:
+            click.secho(f"CSSL VSCode extension installed! (v{current_version})", fg='green', bold=True)
         click.echo()
         click.echo(f"Installed to: {target_dir}")
         click.echo()
         click.echo("Features:")
         click.echo("  - Syntax highlighting for .cssl, .cssl-pl, .cssl-mod files")
-        click.echo("  - BruteInjection operators: <==, ==>, <<==, +<==, etc.")
-        click.echo("  - Type highlighting: int, string, stack<T>, datastruct<T>")
+        click.echo("  - OOP support: class, constructor, this->member")
+        click.echo("  - Injection operators: <== (brute), <<== (infuse)")
+        click.echo("  - Type highlighting: int, string, stack<T>, instance<>")
         click.echo("  - Global references: @Name, r@Name, s@Name")
         click.echo("  - Shared objects: $Name")
-        click.echo("  - Filter helpers: string::contains, json::key, etc.")
         click.echo()
         click.secho("Restart VSCode to activate the extension.", fg='yellow')
 
@@ -7740,35 +7927,28 @@ cli.add_command(cssl)
 def vscode(force, stubs_only):
     """Initialize or update VSCode configuration for IncludeCPP/CSSL.
 
-    Sets up .vscode folder with:
-    - CSSL language support (syntax highlighting, snippets)
-    - Type stubs for builtins (.pyi files)
-    - Auto-generated stubs for your plugins and modules
+    Installs CSSL extension globally and sets up project stubs.
 
     \b
     Usage:
-      includecpp vscode           # Initialize .vscode
-      includecpp vscode --force   # Force overwrite existing
+      includecpp vscode           # Install/update extension + stubs
+      includecpp vscode --force   # Force reinstall extension
       includecpp vscode --stubs-only  # Only update stubs
 
     \b
-    What it creates:
-      .vscode/
-        settings.json         - VSCode settings for CSSL
-        cssl/                 - CSSL language extension
-        stubs/                - Type stubs for IDE support
-          cssl_builtins.pyi   - CSSL builtin functions
-          plugins/            - Stubs for your .cp plugins
-          modules/            - Stubs for your modules
+    What it does:
+      1. Installs CSSL extension globally (~/.vscode/extensions/)
+      2. Creates .vscode/settings.json with file associations
+      3. Creates .vscode/stubs/ with type hints for IDE support
     """
     from pathlib import Path as PathLib
+    import os
 
     cwd = PathLib.cwd()
     vscode_dir = cwd / '.vscode'
     stubs_dir = vscode_dir / 'stubs'
     plugins_stubs_dir = stubs_dir / 'plugins'
     modules_stubs_dir = stubs_dir / 'modules'
-    cssl_ext_dir = vscode_dir / 'cssl'
 
     # Create directories
     vscode_dir.mkdir(exist_ok=True)
@@ -7784,56 +7964,79 @@ def vscode(force, stubs_only):
     updated_count = 0
     created_count = 0
 
-    # 1. Copy CSSL extension files (unless stubs-only)
+    # 1. Install CSSL extension GLOBALLY (unless stubs-only)
     if not stubs_only:
-        click.secho("Setting up CSSL language support...", fg='yellow')
+        click.secho("Installing CSSL extension globally...", fg='yellow')
 
         # Find source extension directory
         source_ext_dir = PathLib(__file__).parent.parent / 'vscode' / 'cssl'
 
         if source_ext_dir.exists():
-            cssl_ext_dir.mkdir(exist_ok=True)
-
-            # Copy extension files
-            ext_files = [
-                'language-configuration.json',
-                'package.json',
-            ]
-
-            for fname in ext_files:
-                src = source_ext_dir / fname
-                dst = cssl_ext_dir / fname
-                if src.exists():
-                    if not dst.exists() or force:
-                        shutil.copy2(src, dst)
-                        created_count += 1
-                        click.echo(f"  Created: .vscode/cssl/{fname}")
-
-            # Copy syntaxes folder
-            syntaxes_src = source_ext_dir / 'syntaxes'
-            syntaxes_dst = cssl_ext_dir / 'syntaxes'
-            if syntaxes_src.exists():
-                syntaxes_dst.mkdir(exist_ok=True)
-                for f in syntaxes_src.glob('*.json'):
-                    dst = syntaxes_dst / f.name
-                    if not dst.exists() or force:
-                        shutil.copy2(f, dst)
-                        created_count += 1
-                        click.echo(f"  Created: .vscode/cssl/syntaxes/{f.name}")
-
-            # Copy snippets folder
-            snippets_src = source_ext_dir / 'snippets'
-            snippets_dst = cssl_ext_dir / 'snippets'
-            if snippets_src.exists():
-                snippets_dst.mkdir(exist_ok=True)
-                for f in snippets_src.glob('*.json'):
-                    dst = snippets_dst / f.name
-                    if not dst.exists() or force:
-                        shutil.copy2(f, dst)
-                        created_count += 1
-                        click.echo(f"  Created: .vscode/cssl/snippets/{f.name}")
+            # Get version from package.json
+            pkg_json = source_ext_dir / 'package.json'
+            current_version = "1.1.0"
+            if pkg_json.exists():
+                try:
+                    pkg_data = json.loads(pkg_json.read_text(encoding='utf-8'))
+                    current_version = pkg_data.get('version', '1.1.0')
+                except:
+                    pass
+
+            # Find global VSCode extensions directory
+            if os.name == 'nt':  # Windows
+                global_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode' / 'extensions'
+            else:  # Linux/Mac
+                global_ext_dir = PathLib.home() / '.vscode' / 'extensions'
+
+            if not global_ext_dir.exists():
+                # Try VSCode Insiders
+                if os.name == 'nt':
+                    global_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode-insiders' / 'extensions'
+                else:
+                    global_ext_dir = PathLib.home() / '.vscode-insiders' / 'extensions'
+
+            if global_ext_dir.exists():
+                target_dir = global_ext_dir / f'includecpp.cssl-{current_version}'
+
+                # Check if already installed with same or older version
+                needs_install = force
+                existing_version = None
+
+                # Find existing installations
+                for existing in global_ext_dir.glob('includecpp.cssl-*'):
+                    existing_version = existing.name.split('-')[-1]
+                    if existing_version != current_version:
+                        # Remove old version
+                        click.echo(f"  Removing old version: {existing_version}")
+                        shutil.rmtree(existing)
+                        needs_install = True
+                    elif not force:
+                        click.echo(f"  Already installed: v{current_version}")
+                        needs_install = False
+
+                if not target_dir.exists():
+                    needs_install = True
+
+                if needs_install:
+                    # Remove target if exists (force reinstall)
+                    if target_dir.exists():
+                        shutil.rmtree(target_dir)
+
+                    # Copy extension to global directory
+                    shutil.copytree(source_ext_dir, target_dir)
+                    created_count += 1
+
+                    if existing_version and existing_version != current_version:
+                        click.secho(f"  Updated: v{existing_version} -> v{current_version}", fg='green')
+                    else:
+                        click.secho(f"  Installed: v{current_version}", fg='green')
 
-            click.secho("  CSSL extension configured", fg='green')
+                    click.echo(f"  Location: {target_dir}")
+                    click.echo()
+                    click.secho("  Restart VSCode to activate the extension!", fg='yellow', bold=True)
+            else:
+                click.secho("  VSCode extensions directory not found.", fg='red')
+                click.echo("  Make sure VSCode is installed.")
         else:
             click.secho("  Warning: CSSL extension source not found", fg='yellow')
 

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.7.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 
@@ -41,22 +41,25 @@
 ```python
 from includecpp import CSSL
 
-# Initialize CSSL
-CSSL.CsslLang()
-
-# Execute code
-CSSL.exec("""
+# Execute code (v3.7.6+: use run() instead of exec())
+CSSL.run("""
     printl("Hello CSSL!");
 """)
 
 # With parameters and return value
-result = CSSL.exec("""
+result = CSSL.run("""
     string name = parameter.get(0);
     printl("Hello " + name);
     parameter.return(true);
 """, "World")
 
 print(result)  # True
+
+# Create typed scripts and modules (v3.7.6+)
+main = CSSL.script("cssl", '''printl("Main");''')
+payload = CSSL.script("cssl-pl", '''void helper() { printl("Helper!"); }''')
+mod = CSSL.makemodule(main, payload, "mymod")
+mod.helper()  # Call function directly
 ```
 
 ### CLI Execution
@@ -701,12 +704,24 @@ super void forceRun() {
 
 ### shuffled
 
-Allows multiple return values.
+Allows multiple return values with tuple unpacking.
 
 ```cssl
 shuffled string getNames() {
     return "Alice", "Bob", "Charlie";
 }
+
+// Tuple unpacking (v3.7.6+)
+a, b, c = getNames();
+printl(a);  // "Alice"
+printl(b);  // "Bob"
+printl(c);  // "Charlie"
+
+// Works with any types
+shuffled getValues() {
+    return "text", 42, true;
+}
+name, num, flag = getValues();
 ```
 
 ---
@@ -1143,6 +1158,10 @@ print(stats.total)  # 50 - Persisted!
 
 CodeInfusion enables modifying functions at runtime.
 
+> **Important**: Injection operators must be written **without spaces**:
+> - ✓ `func() <<==` / `func() +<<==` / `func() -<<==` (correct)
+> - ✗ `func() < <==` / `func() + <<==` / `func() - <<==` (wrong)
+
 ### <<== (Replace)
 
 Replaces function content.

includecpp/core/cssl/__init__.py

@@ -1,5 +1,5 @@
 """
-CSSL - CSO Service Script Language
+CSSL - C-Style Scripting Language
 Bundled with IncludeCPP for integrated scripting support.
 
 Features:
@@ -16,7 +16,10 @@ from .cssl_parser import (
     CSSLSyntaxError, CSSLLexer, CSSLParser, ASTNode,
     KEYWORDS, TYPE_GENERICS, TYPE_PARAM_FUNCTIONS, INJECTION_HELPERS
 )
-from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
+from .cssl_runtime import (
+    CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file,
+    register_filter, unregister_filter, get_custom_filters
+)
 from .cssl_types import (
     DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
     OpenFind, Parameter, Stack, Vector, Array,
@@ -33,6 +36,8 @@ __all__ = [
     # Runtime
     'CSSLRuntime', 'CSSLRuntimeError', 'CSSLServiceRunner',
     'run_cssl', 'run_cssl_file',
+    # Filter Registration
+    'register_filter', 'unregister_filter', 'get_custom_filters',
     # Data Types
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
     'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array',