IncludeCPP 3.7.9__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.9"
+__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

@@ -7720,7 +7720,13 @@ def cssl_doc(search, list_sections):
                     click.echo("Or use: includecpp cssl doc --list")
         else:
             # Full documentation mode
-            click.echo_via_pager(content)
+            # 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")
@@ -7858,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')
 
@@ -7901,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)
@@ -7945,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/__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',

includecpp/core/cssl/cssl_builtins.py

@@ -307,6 +307,10 @@ class CSSLBuiltins:
         self._functions['dataspace'] = self.builtin_dataspace
         self._functions['openquote'] = self.builtin_openquote
         self._functions['OpenFind'] = self.builtin_openfind
+        self._functions['vector'] = self.builtin_vector
+        self._functions['array'] = self.builtin_array
+        self._functions['stack'] = self.builtin_stack
+        self._functions['map'] = self.builtin_map
 
         # Print aliases for CSSL
         self._functions['printl'] = self.builtin_println  # CSSL uses printl for println
@@ -433,13 +437,50 @@ class CSSLBuiltins:
     # ============= Type Checking =============
 
     def builtin_typeof(self, value: Any) -> str:
-        """Get type name"""
+        """Get type name - returns CSSL-specific type names for CSSL types"""
         if value is None:
             return 'null'
+
+        # Check CSSL-specific types first
+        from .cssl_types import (Vector, Array, Stack, DataStruct,
+                                  List as CSSLList, Dictionary, Map,
+                                  Shuffled, Iterator, Combo, DataSpace,
+                                  OpenQuote, Parameter, CSSLInstance)
+
+        if isinstance(value, Vector):
+            return 'vector'
+        elif isinstance(value, Array):
+            return 'array'
+        elif isinstance(value, Stack):
+            return 'stack'
+        elif isinstance(value, DataStruct):
+            return 'datastruct'
+        elif isinstance(value, CSSLList):
+            return 'list'
+        elif isinstance(value, Dictionary):
+            return 'dictionary'
+        elif isinstance(value, Map):
+            return 'map'
+        elif isinstance(value, Shuffled):
+            return 'shuffled'
+        elif isinstance(value, Iterator):
+            return 'iterator'
+        elif isinstance(value, Combo):
+            return 'combo'
+        elif isinstance(value, DataSpace):
+            return 'dataspace'
+        elif isinstance(value, OpenQuote):
+            return 'openquote'
+        elif isinstance(value, Parameter):
+            return 'parameter'
+        elif isinstance(value, CSSLInstance):
+            return value._class.name
+
+        # Python types as fallback
         type_map = {
             int: 'int',
             float: 'float',
-            str: 'str',
+            str: 'string',
             bool: 'bool',
             list: 'list',
             dict: 'dict',
@@ -1044,6 +1085,13 @@ class CSSLBuiltins:
         Usage: instance::getMethods(@module) or instance::getMethods($obj)
         Returns list of method names.
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return list(obj._class.methods.keys())
+
+        # Handle Python objects
         import inspect
         methods = []
         for name in dir(obj):
@@ -1056,8 +1104,20 @@ class CSSLBuiltins:
     def builtin_instance_getClasses(self, obj: Any) -> list:
         """Get all classes from an object/module.
         Usage: instance::getClasses(@module)
-        Returns list of class names.
+        Returns list of class names (including merged classes).
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            classes = [obj._class.name]  # Primary class
+            # Check for merged class instances in members
+            for name, member in obj._members.items():
+                if isinstance(member, CSSLInstance):
+                    classes.append(member._class.name)
+            return classes
+
+        # Handle Python objects
         import inspect
         classes = []
         for name in dir(obj):
@@ -1070,8 +1130,20 @@ class CSSLBuiltins:
     def builtin_instance_getVars(self, obj: Any) -> list:
         """Get all variables/attributes (non-callable) from an object.
         Usage: instance::getVars(@module)
-        Returns list of variable names.
+        Returns list of variable names (excludes merged class instances).
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            vars_list = []
+            for name, member in obj._members.items():
+                # Exclude merged class instances
+                if not isinstance(member, CSSLInstance):
+                    vars_list.append(name)
+            return vars_list
+
+        # Handle Python objects
         vars_list = []
         for name in dir(obj):
             if not name.startswith('_'):
@@ -1085,12 +1157,31 @@ class CSSLBuiltins:
         Usage: instance::getAll(@module)
         Returns dict with 'methods', 'classes', 'vars' keys.
         """
-        import inspect
+        from .cssl_types import CSSLInstance
+
         result = {
             'methods': [],
             'classes': [],
             'vars': []
         }
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            result['methods'] = list(obj._class.methods.keys())
+            result['classes'] = [obj._class.name]
+
+            # Separate regular vars from merged class instances
+            for name, member in obj._members.items():
+                if isinstance(member, CSSLInstance):
+                    # Merged class - add to classes list
+                    result['classes'].append(member._class.name)
+                else:
+                    # Regular variable
+                    result['vars'].append(name)
+            return result
+
+        # Handle Python objects
+        import inspect
         for name in dir(obj):
             if not name.startswith('_'):
                 attr = getattr(obj, name, None)
@@ -1106,21 +1197,46 @@ class CSSLBuiltins:
         """Dynamically call a method on an object.
         Usage: instance::call(@module, 'methodName', arg1, arg2)
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            if obj.has_method(method_name):
+                # Need runtime to call the method
+                if self.runtime:
+                    return self.runtime._call_method(obj, obj.get_method(method_name), list(args), kwargs or {})
+            raise RuntimeError(f"Method '{method_name}' not found on CSSL instance")
+
+        # Handle Python objects
         method = getattr(obj, method_name, None)
         if method and callable(method):
             return method(*args, **kwargs)
         raise RuntimeError(f"Method '{method_name}' not found on object")
 
     def builtin_instance_has(self, obj: Any, name: str) -> bool:
-        """Check if object has an attribute.
+        """Check if object has an attribute or method.
         Usage: instance::has(@module, 'methodName')
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return obj.has_member(name) or obj.has_method(name)
+
+        # Handle Python objects
         return hasattr(obj, name)
 
     def builtin_instance_type(self, obj: Any) -> str:
         """Get the type name of an object.
         Usage: instance::type(@module)
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return obj._class.name
+
+        # Handle Python objects
         return type(obj).__name__
 
     def builtin_isavailable(self, name_or_obj: Any) -> bool:
@@ -1140,6 +1256,50 @@ class CSSLBuiltins:
         # Otherwise, check if the object is not None (for $name or instance<"name">)
         return name_or_obj is not None
 
+    # ============= Filter Registration Functions =============
+
+    def builtin_filter_register(self, filter_type: str, helper: str, callback: Any) -> bool:
+        """Register a custom filter.
+        Usage: filter::register("mytype", "where", myCallback)
+
+        The callback receives (source, filter_value, runtime) and returns filtered result.
+        Use "*" as helper for catch-all.
+
+        Example:
+            define myFilter(source, value, runtime) {
+                return source + value;
+            }
+            filter::register("custom", "add", myFilter);
+
+            result <==[custom::add=10] 5;  // result = 15
+        """
+        from .cssl_runtime import register_filter
+        register_filter(filter_type, helper, callback)
+        return True
+
+    def builtin_filter_unregister(self, filter_type: str, helper: str) -> bool:
+        """Unregister a custom filter.
+        Usage: filter::unregister("mytype", "where")
+        """
+        from .cssl_runtime import unregister_filter
+        return unregister_filter(filter_type, helper)
+
+    def builtin_filter_list(self) -> list:
+        """List all registered custom filters.
+        Usage: filter::list()
+        Returns list of filter keys like ["mytype::where", "custom::*"]
+        """
+        from .cssl_runtime import get_custom_filters
+        return list(get_custom_filters().keys())
+
+    def builtin_filter_exists(self, filter_type: str, helper: str) -> bool:
+        """Check if a custom filter exists.
+        Usage: filter::exists("mytype", "where")
+        """
+        from .cssl_runtime import get_custom_filters
+        key = f"{filter_type}::{helper}"
+        return key in get_custom_filters()
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:
@@ -1680,7 +1840,7 @@ class CSSLBuiltins:
 
     def builtin_cso_root(self, path: str = "") -> str:
         """
-        Get absolute path relative to CSO root directory
+        Get absolute path relative to project root directory
         Usage: cso_root('/services/myservice.cssl')
         Returns: Full absolute path to the file
         """
@@ -1729,7 +1889,7 @@ class CSSLBuiltins:
             if os.path.exists(cwd_path):
                 filepath = cwd_path
             else:
-                # Fall back to cso_root for CSO service context
+                # Fall back to cso_root for service context
                 filepath = self.builtin_cso_root(filepath)
 
         # Check file exists
@@ -1923,7 +2083,7 @@ class CSSLBuiltins:
                 if os.path.exists(cwd_path):
                     filepath = cwd_path
                 else:
-                    # Fall back to cso_root for CSO service context
+                    # Fall back to cso_root for service context
                     filepath = self.builtin_cso_root(filepath)
 
             # Check file exists
@@ -2203,6 +2363,38 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
+    def builtin_vector(self, element_type: str = 'dynamic') -> Any:
+        """Create a vector container.
+
+        Usage: vector<int> myVector; or vector('int')
+        """
+        from .cssl_types import Vector
+        return Vector(element_type)
+
+    def builtin_array(self, element_type: str = 'dynamic') -> Any:
+        """Create an array container.
+
+        Usage: array<string> myArray; or array('string')
+        """
+        from .cssl_types import Array
+        return Array(element_type)
+
+    def builtin_stack(self, element_type: str = 'dynamic') -> Any:
+        """Create a stack container.
+
+        Usage: stack<int> myStack; or stack('int')
+        """
+        from .cssl_types import Stack
+        return Stack(element_type)
+
+    def builtin_map(self, key_type: str = 'dynamic', value_type: str = 'dynamic') -> Any:
+        """Create a map container.
+
+        Usage: map<string, int> myMap; or map('string', 'int')
+        """
+        from .cssl_types import Map
+        return Map(key_type, value_type)
+
     def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.