codeupipe 0.1.0__py3-none-any.whl

codeupipe/converter/__init__.py

@@ -0,0 +1,9 @@
+"""
+Converter: CUP ↔ Standard Python bidirectional conversion.
+
+Built with CUP — the converter itself is a set of Filters and Pipelines.
+"""
+
+from .config import load_config, DEFAULT_CONFIG, PATTERN_DEFAULTS
+
+__all__ = ["load_config", "DEFAULT_CONFIG", "PATTERN_DEFAULTS"]

codeupipe/converter/config.py

@@ -0,0 +1,119 @@
+"""
+Config: Conversion configuration parsing.
+
+Reads .cup.json (zero deps) or pyproject.toml [tool.cup] (Python 3.11+).
+Provides sensible defaults for MVC, Clean, Hexagonal, and Flat patterns.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+__all__ = ["load_config", "DEFAULT_CONFIG", "PATTERN_DEFAULTS"]
+
+
+PATTERN_DEFAULTS: Dict[str, Dict[str, Any]] = {
+    "mvc": {
+        "roles": {
+            "model": ["fetch_*", "save_*", "db_*", "load_*", "store_*"],
+            "view": ["format_*", "render_*", "serialize_*", "display_*"],
+            "controller": ["validate_*", "authorize_*", "calc_*", "process_*", "route_*"],
+            "middleware": ["_tap", "_hook", "_valve"],
+        },
+        "output": {
+            "model": "models/",
+            "view": "views/",
+            "controller": "controllers/",
+            "middleware": "middleware/",
+        },
+    },
+    "clean": {
+        "roles": {
+            "entity": ["_payload"],
+            "use_case": ["calc_*", "process_*", "validate_*", "apply_*", "check_*"],
+            "interface_adapter": ["fetch_*", "save_*", "db_*", "send_*", "_tap", "_valve"],
+            "framework": ["_hook", "retry_*", "log_*"],
+        },
+        "output": {
+            "entity": "entities/",
+            "use_case": "use_cases/",
+            "interface_adapter": "interface_adapters/",
+            "framework": "frameworks/",
+        },
+    },
+    "hexagonal": {
+        "roles": {
+            "domain": ["calc_*", "process_*", "validate_*", "apply_*", "check_*"],
+            "adapter_inbound": ["parse_*", "deserialize_*", "route_*"],
+            "adapter_outbound": ["fetch_*", "save_*", "db_*", "send_*", "publish_*"],
+            "port": ["_protocol"],
+            "infrastructure": ["_tap", "_hook", "_valve", "retry_*", "log_*"],
+        },
+        "output": {
+            "domain": "domain/",
+            "adapter_inbound": "adapters/inbound/",
+            "adapter_outbound": "adapters/outbound/",
+            "port": "ports/",
+            "infrastructure": "infrastructure/",
+        },
+    },
+    "flat": {
+        "roles": {
+            "step": ["*"],
+        },
+        "output": {
+            "step": "steps/",
+        },
+    },
+}
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    "pattern": "flat",
+    "roles": PATTERN_DEFAULTS["flat"]["roles"],
+    "output": {
+        "base": "src/",
+        **PATTERN_DEFAULTS["flat"]["output"],
+    },
+}
+
+
+def load_config(config_path: Optional[str] = None, pattern: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Load conversion config from .cup.json, or fall back to pattern defaults.
+
+    Priority:
+    1. Explicit config_path (.cup.json)
+    2. Pattern name → built-in defaults
+    3. DEFAULT_CONFIG (flat)
+    """
+    if config_path:
+        path = Path(config_path)
+        if path.exists() and path.suffix == ".json":
+            with open(path) as f:
+                config = json.load(f)
+            return _resolve_config(config)
+
+    if pattern and pattern in PATTERN_DEFAULTS:
+        return _resolve_config({"pattern": pattern})
+
+    return DEFAULT_CONFIG.copy()
+
+
+def _resolve_config(raw: Dict[str, Any]) -> Dict[str, Any]:
+    """Merge raw config with pattern defaults."""
+    pattern = raw.get("pattern", "flat")
+    defaults = PATTERN_DEFAULTS.get(pattern, PATTERN_DEFAULTS["flat"])
+
+    roles = raw.get("roles", defaults["roles"])
+    output_dirs = raw.get("output", {})
+    base = output_dirs.pop("base", "src/") if isinstance(output_dirs, dict) else "src/"
+
+    # Merge: explicit output dirs override pattern defaults
+    resolved_output = {**defaults["output"], **output_dirs}
+    resolved_output["base"] = base
+
+    return {
+        "pattern": pattern,
+        "roles": roles,
+        "output": resolved_output,
+    }

codeupipe/converter/filters/__init__.py

@@ -0,0 +1,21 @@
+"""
+Converter Filters — CUP Filters that power the conversion pipelines.
+"""
+
+from .parse_config import ParseConfigFilter
+from .analyze import AnalyzePipelineFilter
+from .classify import ClassifyStepsFilter
+from .classify_files import ClassifyFilesFilter
+from .generate_export import GenerateExportFilter
+from .scan_project import ScanProjectFilter
+from .generate_import import GenerateImportFilter
+
+__all__ = [
+    "ParseConfigFilter",
+    "AnalyzePipelineFilter",
+    "ClassifyStepsFilter",
+    "ClassifyFilesFilter",
+    "GenerateExportFilter",
+    "ScanProjectFilter",
+    "GenerateImportFilter",
+]

codeupipe/converter/filters/analyze.py

@@ -0,0 +1,60 @@
+"""
+AnalyzePipelineFilter: Introspects a CUP Pipeline and extracts its step manifest.
+"""
+
+import inspect
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class AnalyzePipelineFilter:
+    """
+    Filter: Analyze a CUP Pipeline instance and extract step metadata.
+
+    Input payload keys:
+        - pipeline: A Pipeline instance to analyze
+
+    Output payload adds:
+        - steps (list[dict]): Step manifest with name, type, class info
+        - hooks (list[dict]): Hook manifest with class info
+    """
+
+    def call(self, payload):
+        pipeline = payload.get("pipeline")
+        if pipeline is None:
+            raise ValueError("Payload must contain 'pipeline' key")
+
+        steps = []
+        for name, instance, step_type in pipeline._steps:
+            info: Dict[str, Any] = {
+                "name": name,
+                "type": step_type,
+                "class_name": instance.__class__.__name__,
+                "is_valve": hasattr(instance, "_predicate"),
+            }
+
+            if info["is_valve"]:
+                info["type"] = "valve"
+                info["inner_class"] = instance._inner.__class__.__name__
+
+            # Try to capture source for export
+            try:
+                info["source"] = inspect.getsource(instance.__class__)
+            except (OSError, TypeError):
+                info["source"] = None
+
+            steps.append(info)
+
+        hooks: List[Dict[str, Any]] = []
+        for hook in pipeline._hooks:
+            hook_info: Dict[str, Any] = {
+                "class_name": hook.__class__.__name__,
+                "type": "hook",
+            }
+            try:
+                hook_info["source"] = inspect.getsource(hook.__class__)
+            except (OSError, TypeError):
+                hook_info["source"] = None
+            hooks.append(hook_info)
+
+        return payload.insert("steps", steps).insert("hooks", hooks)

codeupipe/converter/filters/classify.py

@@ -0,0 +1,52 @@
+"""
+ClassifyStepsFilter: Maps pipeline steps to architectural roles using config patterns.
+"""
+
+import fnmatch
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class ClassifyStepsFilter:
+    """
+    Filter: Classify pipeline steps into architectural roles.
+
+    Input payload keys:
+        - steps (list[dict]): Step manifest from AnalyzePipelineFilter
+        - hooks (list[dict]): Hook manifest from AnalyzePipelineFilter
+        - config (dict): Resolved config with 'roles' mapping
+
+    Output payload adds:
+        - classified (dict[str, list[dict]]): role_name → list of steps
+    """
+
+    def call(self, payload):
+        steps = payload.get("steps", [])
+        hooks = payload.get("hooks", [])
+        config = payload.get("config", {})
+        roles = config.get("roles", {})
+
+        classified: Dict[str, List[Dict[str, Any]]] = {}
+
+        for step in steps:
+            role = _match_role(step["name"], step["type"], roles)
+            classified.setdefault(role, []).append(step)
+
+        for hook in hooks:
+            role = _match_role(hook["class_name"], "hook", roles)
+            classified.setdefault(role, []).append(hook)
+
+        return payload.insert("classified", classified)
+
+
+def _match_role(name: str, step_type: str, roles: Dict[str, List[str]]) -> str:
+    """Match a step name/type against role glob patterns."""
+    for role, patterns in roles.items():
+        for pattern in patterns:
+            # Type-based special tokens
+            if pattern.startswith("_") and pattern == f"_{step_type}":
+                return role
+            # Name-based glob matching
+            if fnmatch.fnmatch(name, pattern):
+                return role
+    return "uncategorized"

codeupipe/converter/filters/classify_files.py

@@ -0,0 +1,61 @@
+"""
+ClassifyFilesFilter: Maps scanned project files to CUP roles by directory location.
+"""
+
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class ClassifyFilesFilter:
+    """
+    Filter: Classify scanned files into roles based on their directory.
+
+    Input payload keys:
+        - source_files (list[dict]): Files from ScanProjectFilter
+        - config (dict): Config with output dirs mapping
+
+    Output payload adds:
+        - classified_files (dict[str, list[dict]]): role → files
+    """
+
+    def call(self, payload):
+        source_files = payload.get("source_files", [])
+        config = payload.get("config", {})
+        output = config.get("output", {})
+
+        # Build reverse map: directory → role
+        dir_to_role: Dict[str, str] = {}
+        for role, directory in output.items():
+            if role == "base":
+                continue
+            # Normalize: strip trailing slash
+            normalized = directory.rstrip("/")
+            dir_to_role[normalized] = role
+
+        classified: Dict[str, List[Dict[str, Any]]] = {}
+
+        for file_info in source_files:
+            file_dir = file_info.get("dir", "")
+            role = _match_dir_to_role(file_dir, dir_to_role)
+            classified.setdefault(role, []).append(file_info)
+
+        return payload.insert("classified_files", classified)
+
+
+def _match_dir_to_role(file_dir: str, dir_to_role: Dict[str, str]) -> str:
+    """Match a file's directory to the closest role."""
+    normalized = file_dir.rstrip("/")
+
+    # Normalize keys too (strip trailing slashes)
+    normalized_map = {k.rstrip("/"): v for k, v in dir_to_role.items()}
+
+    # Exact match
+    if normalized in normalized_map:
+        return normalized_map[normalized]
+
+    # Check if file_dir is under a role directory (must have / separator)
+    for directory, role in normalized_map.items():
+        if normalized.startswith(directory + "/"):
+            return role
+
+    return "uncategorized"

codeupipe/converter/filters/generate_export.py

@@ -0,0 +1,187 @@
+"""
+GenerateExportFilter: Generates standard Python code from classified CUP steps.
+"""
+
+import os
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class GenerateExportFilter:
+    """
+    Filter: Generate standard Python files from classified CUP steps.
+
+    Input payload keys:
+        - classified (dict[str, list[dict]]): role → steps
+        - config (dict): Config with output dirs
+        - steps (list[dict]): Original step order (for orchestrator)
+
+    Output payload adds:
+        - files (list[dict]): {"path": str, "content": str} for each generated file
+    """
+
+    def call(self, payload):
+        classified = payload.get("classified", {})
+        config = payload.get("config", {})
+        steps = payload.get("steps", [])
+        hooks = payload.get("hooks", [])
+
+        output = config.get("output", {})
+        base = output.get("base", "src/")
+        pattern = config.get("pattern", "flat")
+
+        files: List[Dict[str, str]] = []
+
+        # Generate a file for each step
+        for role, role_steps in classified.items():
+            target_dir = output.get(role, f"{role}/")
+            for step in role_steps:
+                name = step.get("name", step.get("class_name", "unknown"))
+                filename = f"{name}.py"
+                filepath = os.path.join(base, target_dir, filename)
+                content = _generate_step_file(step)
+                files.append({"path": filepath, "content": content})
+
+        # Generate the orchestrator
+        orchestrator = _generate_orchestrator(steps, hooks, classified, config)
+        # Orchestrator goes in controller dir (MVC) or root (flat)
+        orch_dir = output.get("controller", output.get("step", ""))
+        orch_path = os.path.join(base, orch_dir, "pipeline.py")
+        files.append({"path": orch_path, "content": orchestrator})
+
+        return payload.insert("files", files)
+
+
+def _generate_step_file(step: Dict[str, Any]) -> str:
+    """Generate a standard Python file for one step."""
+    name = step.get("name", step.get("class_name", "unknown"))
+    step_type = step.get("type", "filter")
+    class_name = step.get("class_name", "Unknown")
+    source = step.get("source")
+
+    lines = [
+        f'"""',
+        f"{name} — converted from CUP {class_name}",
+        f'"""',
+        "",
+    ]
+
+    if step_type in ("filter", "valve"):
+        lines.extend([
+            "",
+            f"def {name}(data: dict) -> dict:",
+            f'    """Converted from CUP Filter: {class_name}."""',
+        ])
+        if source:
+            lines.append(f"    # Original CUP source:")
+            for src_line in source.strip().split("\n"):
+                lines.append(f"    # {src_line}")
+            lines.append("")
+        lines.extend([
+            "    # TODO: implement business logic",
+            "    return data",
+        ])
+
+        # For valves, also emit the predicate
+        if step_type == "valve":
+            lines.extend([
+                "",
+                "",
+                f"def {name}_predicate(data: dict) -> bool:",
+                f'    """Predicate for conditional execution of {name}."""',
+                "    # TODO: implement predicate logic",
+                "    return True",
+            ])
+
+    elif step_type == "tap":
+        lines.extend([
+            "",
+            f"def {name}(data: dict) -> None:",
+            f'    """Converted from CUP Tap: {class_name}. Observe only, no modification."""',
+        ])
+        if source:
+            lines.append(f"    # Original CUP source:")
+            for src_line in source.strip().split("\n"):
+                lines.append(f"    # {src_line}")
+            lines.append("")
+        lines.extend([
+            "    # TODO: implement observation logic (logging, metrics, etc.)",
+            "    pass",
+        ])
+
+    elif step_type == "hook":
+        lines.extend([
+            "",
+            f"class {class_name}Hook:",
+            f'    """Converted from CUP Hook: {class_name}."""',
+            "",
+            "    def before(self, step_name, data):",
+            '        """Called before each step."""',
+            "        pass",
+            "",
+            "    def after(self, step_name, data):",
+            '        """Called after each step."""',
+            "        pass",
+            "",
+            "    def on_error(self, step_name, error, data):",
+            '        """Called when a step raises."""',
+            "        pass",
+        ])
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _generate_orchestrator(
+    steps: List[Dict[str, Any]],
+    hooks: List[Dict[str, Any]],
+    classified: Dict[str, List[Dict[str, Any]]],
+    config: Dict[str, Any],
+) -> str:
+    """Generate the main orchestrator that calls all steps in sequence."""
+    output = config.get("output", {})
+    base = output.get("base", "src/")
+
+    lines = [
+        '"""',
+        "Pipeline orchestrator — calls all steps in sequence.",
+        f"Converted from CUP Pipeline. Pattern: {config.get('pattern', 'flat')}",
+        '"""',
+        "",
+    ]
+
+    # Imports
+    for role, role_steps in classified.items():
+        target_dir = output.get(role, f"{role}/")
+        module_base = target_dir.rstrip("/").replace("/", ".")
+        for step in role_steps:
+            name = step.get("name", step.get("class_name", "unknown"))
+            step_type = step.get("type", "filter")
+            if step_type == "hook":
+                lines.append(f"from {module_base}.{name} import {step.get('class_name', name)}Hook")
+            else:
+                fn_name = name
+                lines.append(f"from {module_base}.{name} import {fn_name}")
+                if step_type == "valve":
+                    lines.append(f"from {module_base}.{name} import {fn_name}_predicate")
+
+    lines.extend(["", "", "def run_pipeline(data: dict) -> dict:", '    """Execute all steps in order."""'])
+
+    # Step calls in original order
+    for step in steps:
+        name = step["name"]
+        step_type = step["type"]
+        if step_type == "valve":
+            lines.append(f"    if {name}_predicate(data):")
+            lines.append(f"        data = {name}(data)")
+        elif step_type == "tap":
+            lines.append(f"    {name}(data)")
+        else:
+            lines.append(f"    data = {name}(data)")
+
+    lines.extend([
+        "    return data",
+        "",
+    ])
+
+    return "\n".join(lines)