IncludeCPP 3.4.10__py3-none-any.whl → 3.5.0__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.4.10"
+__version__ = "3.5.0"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/__init__.pyi

@@ -1,8 +1,9 @@
 """Type stubs for includecpp package - VSCode IntelliSense support."""
 
-from typing import Any, Dict, Optional, List, Literal, overload
+from typing import Any, Dict, Optional, List, Literal, overload, Callable
 from pathlib import Path
 from types import ModuleType
+import threading
 
 # Import generated module wrappers for VSCode autocomplete
 # These are created by 'includecpp rebuild' and provide module-specific type hints
@@ -11,8 +12,135 @@ try:
 except ImportError:
     pass  # Generated during rebuild
 
-# CSSL module - CSO Service Script Language
-from .core import cssl_bridge as CSSL
+
+# ========== CSSL Module - CSO Service Script Language ==========
+class _CSSLModule:
+    """CSSL callable module created via CSSL.module()"""
+    def __call__(self, *args: Any) -> Any:
+        """Execute the module code with arguments."""
+        ...
+
+class _CSSLFunctionModule:
+    """CSSL function module created via CSSL.makemodule()"""
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        """Get a function from the module."""
+        ...
+
+class _CsslLang:
+    """CSSL Language interface."""
+
+    def exec(self, path_or_code: str, *args: Any) -> Any:
+        """Execute CSSL code or file.
+
+        Args:
+            path_or_code: Path to .cssl file or CSSL code string
+            *args: Arguments accessible via parameter.get(index)
+
+        Returns:
+            Execution result
+        """
+        ...
+
+    def T_exec(
+        self,
+        path_or_code: str,
+        *args: Any,
+        callback: Optional[Callable[[Any], None]] = None
+    ) -> threading.Thread:
+        """Execute CSSL code asynchronously in a thread."""
+        ...
+
+    def wait_all(self, timeout: Optional[float] = None) -> None:
+        """Wait for all async executions to complete."""
+        ...
+
+    def get_output(self) -> List[str]:
+        """Get output buffer from last execution."""
+        ...
+
+    def clear_output(self) -> None:
+        """Clear output buffer."""
+        ...
+
+    def set_global(self, name: str, value: Any) -> None:
+        """Set a global variable in CSSL runtime."""
+        ...
+
+    def get_global(self, name: str) -> Any:
+        """Get a global variable from CSSL runtime."""
+        ...
+
+    def module(self, code: str) -> _CSSLModule:
+        """Create a callable CSSL module from code."""
+        ...
+
+    def makemodule(self, code: str) -> _CSSLFunctionModule:
+        """Create a CSSL module with accessible functions."""
+        ...
+
+
+class _CSSLBridge:
+    """CSSL Bridge module - access to CSSL language from Python."""
+
+    CsslLang: type[_CsslLang]
+
+    def exec(self, path_or_code: str, *args: Any) -> Any:
+        """Execute CSSL code or file."""
+        ...
+
+    def _exec(self, code: str, *args: Any) -> Any:
+        """Execute CSSL code (alias for exec)."""
+        ...
+
+    def T_exec(
+        self,
+        path_or_code: str,
+        *args: Any,
+        callback: Optional[Callable[[Any], None]] = None
+    ) -> threading.Thread:
+        """Execute CSSL code asynchronously."""
+        ...
+
+    def _T_exec(
+        self,
+        code: str,
+        *args: Any,
+        callback: Optional[Callable[[Any], None]] = None
+    ) -> threading.Thread:
+        """Execute CSSL code asynchronously (alias)."""
+        ...
+
+    def set_global(self, name: str, value: Any) -> None:
+        """Set a global variable."""
+        ...
+
+    def get_global(self, name: str) -> Any:
+        """Get a global variable."""
+        ...
+
+    def get_output(self) -> List[str]:
+        """Get output buffer."""
+        ...
+
+    def clear_output(self) -> None:
+        """Clear output buffer."""
+        ...
+
+    def module(self, code: str) -> _CSSLModule:
+        """Create a callable CSSL module."""
+        ...
+
+    def makemodule(self, code: str) -> _CSSLFunctionModule:
+        """Create a CSSL function module."""
+        ...
+
+    def get_cssl(self) -> _CsslLang:
+        """Get default CSSL instance."""
+        ...
+
+
+# CSSL module instance - CSO Service Script Language
+CSSL: _CSSLBridge
 
 __version__: str
 

includecpp/cli/commands.py

@@ -7139,20 +7139,21 @@ def cppy_types():
 # EXEC - Interactive Code Execution
 # ============================================================================
 
-@cli.command()
-@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++']))
+@cli.command(name='exec')
+@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++', 'cssl']))
 @click.argument('path', required=False, type=click.Path())
 @click.option('--all', 'import_all', is_flag=True, help='Import all available modules')
-def exec(lang, path, import_all):
+def exec_repl(lang, path, import_all):
     """Execute code interactively for quick testing.
 
-    Run Python or C++ code snippets without creating files.
+    Run Python, C++ or CSSL code snippets without creating files.
     Perfect for testing your IncludeCPP modules quickly.
 
     \b
     Usage:
       includecpp exec py              # Interactive Python
       includecpp exec cpp             # Interactive C++
+      includecpp exec cssl            # Interactive CSSL
       includecpp exec py mymodule     # Auto-import mymodule
       includecpp exec py plugins/x.cp # Auto-import from plugin
       includecpp exec py --all        # Import all modules
@@ -7178,7 +7179,8 @@ def exec(lang, path, import_all):
 
     # Normalize language
     is_python = lang in ('py', 'python')
-    lang_name = 'Python' if is_python else 'C++'
+    is_cssl = lang == 'cssl'
+    lang_name = 'Python' if is_python else ('CSSL' if is_cssl else 'C++')
 
     # Build imports/includes
     imports = []
@@ -7286,6 +7288,7 @@ def exec(lang, path, import_all):
 
     if is_python:
         # Execute Python code
+        import builtins
         full_code = '\n'.join(code_lines)
         try:
             # Use exec with captured output
@@ -7299,7 +7302,7 @@ def exec(lang, path, import_all):
             exec_globals = {'__name__': '__main__'}
 
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(full_code, exec_globals)
+                builtins.exec(full_code, exec_globals)
 
             stdout_val = stdout_capture.getvalue()
             stderr_val = stderr_capture.getvalue()
@@ -7315,6 +7318,29 @@ def exec(lang, path, import_all):
         except Exception as e:
             click.secho(f"Error: {e}", fg='red')
 
+    elif is_cssl:
+        # Execute CSSL code
+        full_code = '\n'.join(lines)
+        try:
+            from ..core.cssl_bridge import CsslLang
+            cssl_lang = CsslLang()
+            result = cssl_lang.exec(full_code)
+
+            # Print any output from the execution
+            output = cssl_lang.get_output()
+            if output:
+                for line in output:
+                    click.echo(line)
+
+            if result is not None:
+                click.echo(result)
+
+            if not output and result is None:
+                click.secho("(no output)", fg='bright_black')
+
+        except Exception as e:
+            click.secho(f"Error: {e}", fg='red')
+
     else:
         # Execute C++ code
         # Build a complete C++ program
@@ -7507,6 +7533,198 @@ def cssl_makemodule(path, output):
     click.echo(f"  Type: {module_data['type']}")
 
 
+@cssl.command(name='doc')
+def cssl_doc():
+    """Show CSSL documentation."""
+    from pathlib import Path as PathLib
+    import os
+
+    # Find the documentation file in the cssl package directory
+    cssl_dir = PathLib(__file__).parent.parent / 'core' / 'cssl'
+    doc_path = cssl_dir / 'CSSL_DOCUMENTATION.md'
+
+    if not doc_path.exists():
+        # Try alternative locations
+        alt_paths = [
+            PathLib(__file__).parent.parent.parent / 'CSSL_DOCUMENTATION.md',
+            PathLib(__file__).parent.parent / 'CSSL_DOCUMENTATION.md',
+            PathLib(os.getcwd()) / 'CSSL_DOCUMENTATION.md',
+        ]
+        for alt in alt_paths:
+            if alt.exists():
+                doc_path = alt
+                break
+
+    if doc_path.exists():
+        content = doc_path.read_text(encoding='utf-8')
+        # Use pager for long content
+        click.echo_via_pager(content)
+    else:
+        click.secho("Documentation file not found.", fg='yellow')
+        click.echo("Looking for: CSSL_DOCUMENTATION.md")
+        click.echo()
+        click.echo("Quick Reference:")
+        click.echo("  - Variables: string x = \"hello\"; int n = 42;")
+        click.echo("  - Functions: void foo() { } or define bar() { }")
+        click.echo("  - Loops: for (i in range(0, 10)) { } or for (int i = 0; i < 10; i++) { }")
+        click.echo("  - Conditions: if (x) { } elif (y) { } else { }")
+        click.echo("  - Containers: stack<T>, vector<T>, array<T>")
+        click.echo("  - Globals: global x = value; @x")
+        click.echo("  - Payloads: payload(\"file.cssl-pl\");")
+        click.echo()
+        click.echo("For full docs, see: https://github.com/liliassg/IncludeCPP")
+
+
+@cssl.command(name='create')
+@click.argument('name')
+@click.option('--dir', '-d', type=click.Path(), default='.', help='Output directory')
+def cssl_create(name, dir):
+    """Create a new CSSL project with .cssl and .cssl-pl files."""
+    from pathlib import Path as PathLib
+
+    out_dir = PathLib(dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    cssl_file = out_dir / f"{name}.cssl"
+    payload_file = out_dir / f"{name}.cssl-pl"
+
+    # Create .cssl file
+    cssl_content = f'''// {name}.cssl - CSSL Application
+// Created with: includecpp cssl create {name}
+
+// Load payload (globals, injections, config)
+payload("{name}.cssl-pl");
+
+// Main application code
+void main() {{
+    printl("Hello from {name}!");
+    printl("Version: " + @version);
+}}
+
+main();
+'''
+
+    # Create .cssl-pl payload file
+    payload_content = f'''// {name}.cssl-pl - CSSL Payload
+// Loaded via: payload("{name}.cssl-pl");
+
+// ============================================================================
+// Configuration & Variables
+// ============================================================================
+global version = "1.0.0";
+global appName = "{name}";
+global debug = false;
+
+// ============================================================================
+// Builtin Injections
+// ============================================================================
+// Inject cleanup code into exit()
+exit() <<== {{
+    if (@debug) {{
+        printl("[DEBUG] {name} shutting down...");
+    }}
+}}
+
+// ============================================================================
+// Helper Functions (globally callable via @functionName)
+// ============================================================================
+void log(string message) {{
+    if (@debug) {{
+        printl("[LOG] " + message);
+    }}
+}}
+
+void error(string message) {{
+    printl("[ERROR] " + message);
+}}
+'''
+
+    # Write files
+    cssl_file.write_text(cssl_content, encoding='utf-8')
+    payload_file.write_text(payload_content, encoding='utf-8')
+
+    click.secho(f"Created CSSL project: {name}", fg='green', bold=True)
+    click.echo()
+    click.echo("Files created:")
+    click.echo(f"  {cssl_file}  - Main application")
+    click.echo(f"  {payload_file}  - Payload (globals, injections)")
+    click.echo()
+    click.echo("Run with:")
+    click.secho(f"  includecpp cssl exec {cssl_file}", fg='cyan')
+    click.echo()
+    click.echo("Or from Python:")
+    click.echo("  from includecpp import CSSL")
+    click.echo(f"  CSSL.exec('{cssl_file}')")
+
+
+@cssl.command(name='vscode')
+def cssl_vscode():
+    """Install VSCode extension for CSSL syntax highlighting."""
+    from pathlib import Path as PathLib
+    import shutil
+    import os
+
+    # Find VSCode extensions directory
+    if os.name == 'nt':  # Windows
+        vscode_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode' / 'extensions'
+    else:  # Linux/Mac
+        vscode_ext_dir = PathLib.home() / '.vscode' / 'extensions'
+
+    if not vscode_ext_dir.exists():
+        # Try VSCode Insiders
+        if os.name == 'nt':
+            vscode_ext_dir = PathLib(os.environ.get('USERPROFILE', '')) / '.vscode-insiders' / 'extensions'
+        else:
+            vscode_ext_dir = PathLib.home() / '.vscode-insiders' / 'extensions'
+
+    if not vscode_ext_dir.exists():
+        click.secho("VSCode extensions directory not found.", fg='red')
+        click.echo("Make sure VSCode is installed.")
+        click.echo()
+        click.echo("Expected locations:")
+        if os.name == 'nt':
+            click.echo(f"  %USERPROFILE%\\.vscode\\extensions")
+        else:
+            click.echo(f"  ~/.vscode/extensions")
+        return
+
+    # Find our bundled extension
+    package_dir = PathLib(__file__).parent.parent
+    source_ext_dir = package_dir / 'vscode' / 'cssl'
+
+    if not source_ext_dir.exists():
+        click.secho("CSSL extension files not found in package.", fg='red')
+        return
+
+    # Install extension
+    target_dir = vscode_ext_dir / 'includecpp.cssl-1.0.0'
+
+    try:
+        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)
+        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("  - 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')
+
+    except PermissionError:
+        click.secho("Permission denied. Try running as administrator.", fg='red')
+    except Exception as e:
+        click.secho(f"Installation failed: {e}", fg='red')
+
+
 # Register hidden cssl command group
 cli.add_command(cssl)