mcli-framework 7.10.1__py3-none-any.whl → 7.10.2__py3-none-any.whl

mcli/workflow/notebook/validator.py

@@ -0,0 +1,313 @@
+"""
+Validation utilities for workflow notebooks.
+
+Provides validation for:
+- JSON schema compliance
+- Code syntax checking
+- Shell script validation
+- MCLI API validation
+"""
+
+import ast
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from mcli.lib.logger.logger import get_logger
+
+from .schema import NOTEBOOK_SCHEMA, CellLanguage, CellType, WorkflowNotebook
+
+logger = get_logger()
+
+
+class NotebookValidator:
+    """Validator for workflow notebooks."""
+
+    def __init__(self):
+        self.schema_errors: List[str] = []
+        self.syntax_errors: List[str] = []
+
+    def validate_schema(self, notebook: WorkflowNotebook) -> bool:
+        """
+        Validate notebook against JSON schema.
+
+        Args:
+            notebook: WorkflowNotebook to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        self.schema_errors = []
+
+        try:
+            import jsonschema
+
+            data = notebook.to_dict()
+            jsonschema.validate(instance=data, schema=NOTEBOOK_SCHEMA)
+            return True
+
+        except ImportError:
+            # jsonschema not installed, do basic validation
+            logger.warning("jsonschema not installed, performing basic validation")
+            return self._basic_schema_validation(notebook)
+
+        except Exception as e:
+            self.schema_errors.append(str(e))
+            return False
+
+    def _basic_schema_validation(self, notebook: WorkflowNotebook) -> bool:
+        """Basic schema validation without jsonschema library."""
+        valid = True
+
+        # Check required fields
+        if not notebook.metadata.mcli.name:
+            self.schema_errors.append("Missing required field: metadata.mcli.name")
+            valid = False
+
+        if notebook.nbformat != 4:
+            self.schema_errors.append(f"Invalid nbformat: {notebook.nbformat} (expected 4)")
+            valid = False
+
+        # Validate cells
+        for i, cell in enumerate(notebook.cells):
+            if not cell.cell_type:
+                self.schema_errors.append(f"Cell {i}: Missing cell_type")
+                valid = False
+
+            if not cell.source and not isinstance(cell.source, (str, list)):
+                self.schema_errors.append(f"Cell {i}: Missing or invalid source")
+                valid = False
+
+        return valid
+
+    def validate_syntax(self, notebook: WorkflowNotebook) -> bool:
+        """
+        Validate code syntax in all code cells.
+
+        Args:
+            notebook: WorkflowNotebook to validate
+
+        Returns:
+            True if all code is syntactically valid, False otherwise
+        """
+        self.syntax_errors = []
+        all_valid = True
+
+        for i, cell in enumerate(notebook.cells):
+            if cell.cell_type != CellType.CODE:
+                continue
+
+            language = cell.language
+            code = cell.source_text
+
+            if language == CellLanguage.PYTHON:
+                if not self._validate_python_syntax(code, i):
+                    all_valid = False
+
+            elif language in (CellLanguage.SHELL, CellLanguage.BASH, CellLanguage.ZSH):
+                if not self._validate_shell_syntax(code, i):
+                    all_valid = False
+
+        return all_valid
+
+    def _validate_python_syntax(self, code: str, cell_index: int) -> bool:
+        """Validate Python code syntax."""
+        try:
+            ast.parse(code)
+            return True
+        except SyntaxError as e:
+            self.syntax_errors.append(
+                f"Cell {cell_index} (Python): Syntax error at line {e.lineno}: {e.msg}"
+            )
+            return False
+        except Exception as e:
+            self.syntax_errors.append(f"Cell {cell_index} (Python): {str(e)}")
+            return False
+
+    def _validate_shell_syntax(self, code: str, cell_index: int) -> bool:
+        """Validate shell script syntax using bash -n."""
+        try:
+            # Create temporary file with shell script
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+                f.write(code)
+                temp_path = f.name
+
+            try:
+                # Use bash -n to check syntax without executing
+                result = subprocess.run(
+                    ["bash", "-n", temp_path],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                if result.returncode != 0:
+                    error_msg = result.stderr.strip()
+                    self.syntax_errors.append(f"Cell {cell_index} (Shell): {error_msg}")
+                    return False
+
+                return True
+
+            finally:
+                # Clean up temp file
+                Path(temp_path).unlink(missing_ok=True)
+
+        except subprocess.TimeoutExpired:
+            self.syntax_errors.append(f"Cell {cell_index} (Shell): Validation timeout")
+            return False
+        except Exception as e:
+            self.syntax_errors.append(f"Cell {cell_index} (Shell): {str(e)}")
+            return False
+
+    def validate_mcli_apis(self, notebook: WorkflowNotebook) -> bool:
+        """
+        Validate MCLI API usage in code cells.
+
+        This checks for:
+        - Proper Click decorator usage
+        - MCLI library imports
+        - Common API patterns
+
+        Args:
+            notebook: WorkflowNotebook to validate
+
+        Returns:
+            True if API usage is valid, False otherwise
+        """
+        # TODO: Implement MCLI-specific API validation
+        # This could check for:
+        # - @click.command() or @click.group() decorators
+        # - Proper import statements
+        # - Common anti-patterns
+        return True
+
+    def get_all_errors(self) -> List[str]:
+        """Get all validation errors."""
+        return self.schema_errors + self.syntax_errors
+
+
+class CodeLinter:
+    """Linter for workflow notebook code."""
+
+    def __init__(self):
+        self.issues: List[Dict[str, any]] = []
+
+    def lint_python(self, code: str) -> List[Dict[str, any]]:
+        """
+        Lint Python code using available linters.
+
+        Tries to use (in order):
+        1. flake8
+        2. pylint
+        3. Basic AST-based checks
+
+        Returns:
+            List of lint issues
+        """
+        self.issues = []
+
+        # Try flake8
+        try:
+            import flake8.api.legacy as flake8_api
+
+            style_guide = flake8_api.get_style_guide()
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+                f.write(code)
+                temp_path = f.name
+
+            try:
+                report = style_guide.check_files([temp_path])
+                # Convert flake8 results to our format
+                # (this is simplified - actual implementation would parse flake8 output)
+                if report.total_errors > 0:
+                    self.issues.append(
+                        {
+                            "severity": "warning",
+                            "message": f"Found {report.total_errors} style issues",
+                            "line": 0,
+                        }
+                    )
+            finally:
+                Path(temp_path).unlink(missing_ok=True)
+
+        except ImportError:
+            # flake8 not available, try basic checks
+            self._basic_python_lint(code)
+
+        return self.issues
+
+    def _basic_python_lint(self, code: str):
+        """Basic Python linting using AST."""
+        try:
+            tree = ast.parse(code)
+
+            # Check for common issues
+            for node in ast.walk(tree):
+                # Check for unused imports (simplified)
+                if isinstance(node, ast.Import):
+                    # TODO: Check if imports are actually used
+                    pass
+
+                # Check for bare except
+                if isinstance(node, ast.ExceptHandler) and node.type is None:
+                    self.issues.append(
+                        {
+                            "severity": "warning",
+                            "message": "Bare except clause - consider specifying exception type",
+                            "line": node.lineno,
+                        }
+                    )
+
+        except SyntaxError:
+            # Already caught by syntax validation
+            pass
+
+    def lint_shell(self, code: str) -> List[Dict[str, any]]:
+        """
+        Lint shell script using shellcheck if available.
+
+        Returns:
+            List of lint issues
+        """
+        self.issues = []
+
+        try:
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+                f.write(code)
+                temp_path = f.name
+
+            try:
+                # Try to use shellcheck
+                result = subprocess.run(
+                    ["shellcheck", "-f", "json", temp_path],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+
+                if result.stdout:
+                    import json
+
+                    issues = json.loads(result.stdout)
+                    self.issues = [
+                        {
+                            "severity": issue.get("level", "warning"),
+                            "message": issue.get("message", ""),
+                            "line": issue.get("line", 0),
+                            "code": issue.get("code", ""),
+                        }
+                        for issue in issues
+                    ]
+
+            finally:
+                Path(temp_path).unlink(missing_ok=True)
+
+        except FileNotFoundError:
+            # shellcheck not installed
+            logger.debug("shellcheck not found, skipping shell linting")
+        except Exception as e:
+            logger.warning(f"Shell linting failed: {e}")
+
+        return self.issues

mcli/workflow/workflow.py

@@ -14,5 +14,19 @@ def workflow():
     pass
 
 
+# Add notebook subcommand
+try:
+    from mcli.workflow.notebook.notebook_cmd import notebook
+
+    workflow.add_command(notebook)
+except ImportError as e:
+    # Notebook commands not available
+    import sys
+    from mcli.lib.logger.logger import get_logger
+
+    logger = get_logger()
+    logger.debug(f"Notebook commands not available: {e}")
+
+
 if __name__ == "__main__":
     workflow()

{mcli_framework-7.10.1.dist-info → mcli_framework-7.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.10.1
+Version: 7.10.2
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/commands/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>
@@ -160,6 +160,11 @@ Dynamic: license-file
 
 # MCLI - Portable Workflow Framework
 
+[![codecov](https://codecov.io/gh/gwicho38/mcli/branch/main/graph/badge.svg)](https://codecov.io/gh/gwicho38/mcli)
+[![Tests](https://github.com/gwicho38/mcli/workflows/CI%2FCD%20Pipeline/badge.svg)](https://github.com/gwicho38/mcli/actions)
+[![Python Version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
 **Transform any script into a versioned, portable, schedulable workflow command.**
 
 MCLI is a modular CLI framework that lets you write scripts once and run them anywhere - as interactive commands, scheduled jobs, or background daemons. Your workflows live in `~/.mcli/commands/`, are versioned via lockfile, and completely decoupled from the engine source code.
@@ -170,6 +175,35 @@ Write a script. Store it. Version it. Run it anywhere. Schedule it. Share it.
 
 No coupling to the engine. No vendor lock-in. Just portable workflows that work.
 
+## 🚀 Visual Workflow Editing
+
+Edit your workflow JSON files like Jupyter notebooks with our VSCode extension!
+
+[![VSCode Extension](https://img.shields.io/badge/VSCode-Extension-blue?logo=visualstudiocode)](vscode-extension/)
+[![Visual Editing](https://img.shields.io/badge/workflows-visual%20editing-brightgreen)](vscode-extension/)
+
+**Features:**
+- 📝 Cell-based editing (Jupyter-like interface)
+- ⚡ Live code execution (Python, Shell, Bash, Zsh, Fish)
+- 🎯 Monaco editor with IntelliSense
+- 📊 Rich markdown documentation cells
+- 💾 Files stay as `.json` (git-friendly)
+
+**Quick Install:**
+```bash
+# From VSCode Marketplace (pending publication)
+code --install-extension gwicho38.mcli-framework
+
+# Or install from VSIX
+code --install-extension vscode-extension/mcli-framework-1.0.0.vsix
+```
+
+**Learn More:**
+- [Extension README](vscode-extension/README.md) - Features and usage
+- [Visual Editing Guide](README-VISUAL-EDITING.md) - Quick start
+- [Installation Guide](vscode-extension/INSTALL.md) - Detailed setup
+- [Workflow Notebooks Docs](docs/workflow-notebooks.md) - Complete guide
+
 ## ⚡ Quick Start
 
 ### Installation
@@ -450,7 +484,7 @@ Available workflows:
 - **redis** - Redis cache management
 - **videos** - Video processing and overlay removal
 - **sync** - Multi-cloud synchronization
-- **politician-trading** - Financial data collection (specialized)
+- **politician-trading** - Now available as standalone package: [politician-trading-tracker](https://github.com/gwicho38/politician-trading-tracker)
 
 ## 💡 Why MCLI?