synapseForge 0.1.24.dev2__py3-none-any.whl

pipeline/__init__.py

@@ -0,0 +1 @@
+"""synapseForge — scaffolding pipeline and distribution builder."""

pipeline/init/__init__.py

@@ -0,0 +1,7 @@
+"""Init pipeline — interactive project scaffolding from template.zip.
+
+Usage:
+    python -m pipeline.init [target_directory]
+
+If no target_directory is given, the current working directory is used.
+"""

pipeline/init/__main__.py

@@ -0,0 +1,10 @@
+"""Allow running as ``python -m pipeline.init [target_dir]``."""
+
+import os
+import sys
+
+from .main import run
+
+if __name__ == "__main__":
+    target = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
+    run(target)

pipeline/init/config_handler.py

@@ -0,0 +1,35 @@
+"""Step 5 — Save the user-provided config as ``config/replace.json`` and ``frontend/public/colors.json``."""
+
+import json
+from pathlib import Path
+
+
+CONFIGURABLE_COLOR_KEYS = ("primary", "secondary", "primary_text", "gradient_secondary", "usar_gradiente")
+
+
+def save_config(target: Path, config: dict) -> None:
+    """Write the user config to ``{target}/config/replace.json`` and colors to ``frontend/public/colors.json``.
+
+    Args:
+        target: Project root directory.
+        config: Validated user config dictionary.
+    """
+    config_dir = target / "config"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    dest = config_dir / "replace.json"
+    with open(dest, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    print(f"  Saved: {dest}")
+
+    # Also generate colors.json for runtime in frontend/public/
+    colors = config.get("colors", {})
+    runtime_colors = {k: colors.get(k) for k in CONFIGURABLE_COLOR_KEYS if colors.get(k)}
+    if runtime_colors:
+        public_dir = target / "frontend" / "public"
+        public_dir.mkdir(parents=True, exist_ok=True)
+        colors_dest = public_dir / "colors.json"
+        with open(colors_dest, "w", encoding="utf-8") as f:
+            json.dump(runtime_colors, f, indent=2, ensure_ascii=False)
+        print(f"  Saved: {colors_dest}")

pipeline/init/input_handler.py

@@ -0,0 +1,124 @@
+"""Step 1 — Interactive user input for all replace.json fields."""
+
+import re
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+
+
+def get_user_input() -> Dict[str, object]:
+    """Prompt the user for every field and return a validated config dict.
+
+    Returns:
+        A dictionary with the same structure as ``config/replace.json``.
+    """
+    print("\nIngresá los datos del proyecto (dejá vacío para omitir):\n")
+
+    # ── Logo ────────────────────────────────────────────────────────────
+    logo_path: Optional[str] = _prompt("Logo de la empresa (para README, sin comillas)", required=True)
+    logo_resolved = _resolve_logo(logo_path)
+
+    # ── Project info ────────────────────────────────────────────────────
+    empresa: str = _prompt("Nombre de la empresa desarrolladora", required=True)
+    owner: str = _prompt("Owner del repo (usuario de GitHub)", required=True)
+    legal: str = _prompt("Nombre legal / razón social", required=True)
+    repo: str = _prompt("Nombre del repo", required=True)
+    cliente: str = _prompt("Nombre del cliente", required=True)
+    logo_cliente: str = _prompt("Logo del cliente (para la app, opcional, sin comillas)", default="")
+    descripcion: str = _prompt("Descripción del proyecto", required=True)
+    tarea: str = _prompt("Nombre de la tarea / rubro", required=True)
+
+    # ── Colores (obligatorios) ──────────────────────────────────────────
+    print("\nColores del proyecto:")
+    print("  Primary: color principal (botones, headers, burbujas)")
+    print("  Secondary: color secundario (hover, detalles light)")
+    print("  Primary Text: color de texto (botones, headers)")
+    print("  Gradient Secondary: color secundario del gradiente (igual al primary si no usás gradiente)\n")
+
+    colors: Dict[str, object] = {}
+
+    c = _prompt_hex("Color principal (ej: #D76F10)", required=True)
+    colors["primary"] = c
+
+    c = _prompt_hex("Color secundario (ej: #F0A347)", required=True)
+    colors["secondary"] = c
+
+    c = _prompt_hex("Color de texto (ej: #FFFFFF)", required=True)
+    colors["primary_text"] = c
+
+    # ── Gradient toggle ────────────────────────────────────────────────
+    usar = _prompt("¿Usar gradiente en botones/headers? (s/N)", default="n")
+    colors["usar_gradiente"] = usar.lower() in ("s", "si", "y", "yes", "1", "true")
+    if colors["usar_gradiente"]:
+        c = _prompt_hex("Color secundario del gradiente (ej: #F0A347)", required=True)
+        colors["gradient_secondary"] = c
+    else:
+        colors["gradient_secondary"] = colors["primary"]
+
+    return {
+        "logo": {
+            "path": str(logo_resolved),
+        },
+        "empresa": empresa,
+        "owner": owner,
+        "legal": legal,
+        "repo": repo,
+        "cliente": cliente,
+        "logo_cliente": logo_cliente or None,
+        "descripcion": descripcion,
+        "tarea": tarea,
+        "colors": colors,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Prompt helpers
+# ---------------------------------------------------------------------------
+
+_HEX_RE = re.compile(r"^#[0-9a-fA-F]{6}$")
+
+
+def _prompt(label: str, *, required: bool = False, default: str = "") -> str:
+    """Ask for a text value. Loop until non-empty if *required*."""
+    hint = f" [{default}]" if default else ""
+    suffix = " *" if required else ""
+    while True:
+        value = input(f"  {label}{suffix}{hint}: ").strip()
+        if not value:
+            value = default
+        if value:
+            return value
+        if not required:
+            return ""
+        print("    ⚠ Este campo es obligatorio.")
+
+
+def _prompt_hex(label: str, *, required: bool = False) -> str:
+    """Ask for a hex color. Return hex string if provided.
+
+    Args:
+        label: Prompt label.
+        required: When True, loop until a valid hex is entered.
+
+    Returns:
+        The hex color string, or ``""`` if not required and skipped.
+    """
+    while True:
+        value = input(f"  {label}: ").strip()
+        if not value and not required:
+            return ""
+        if not value:
+            print("    ⚠ Este campo es obligatorio.")
+            continue
+        if _HEX_RE.match(value):
+            return value
+        print("    ⚠ Formato inválido. Usá #RRGGBB (ej: #D76F10).")
+
+
+def _resolve_logo(raw: str) -> Path:
+    """Resolve and validate the logo path."""
+    p = Path(raw).resolve()
+    if not p.is_file():
+        print(f"  ⚠ Archivo no encontrado: {p}")
+        sys.exit(1)
+    return p

pipeline/init/logo_handler.py

@@ -0,0 +1,33 @@
+"""Steps 6-8 — Copy logo, generate .ico, extract colors."""
+
+import shutil
+from pathlib import Path
+from typing import Dict, Optional
+
+
+def handle_logo(config: dict, logo_dest: Path, config_key: str = "logo.path") -> None:
+    """Copy the user's logo to the template assets directory.
+
+    Args:
+        config: User config dictionary.
+        logo_dest: Destination path for the logo.
+        config_key: Dotted config key to read the source from
+            (``logo.path`` for company, ``logo_cliente`` for client).
+    """
+    if config_key == "logo_cliente":
+        logo_src_raw: Optional[str] = config.get("logo_cliente")
+    else:
+        logo_src_raw = config.get("logo", {}).get("path")
+
+    if not logo_src_raw:
+        print(f"  WARNING: no logo path in config, skipping")
+        return
+
+    logo_src = Path(logo_src_raw).resolve()
+    if not logo_src.is_file():
+        print(f"  WARNING: logo source not found: {logo_src}, skipping")
+        return
+
+    logo_dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(str(logo_src), str(logo_dest))
+    print(f"  Copied: {logo_src} → {logo_dest}")

pipeline/init/main.py

@@ -0,0 +1,151 @@
+"""Orchestrates the full init pipeline (steps 1-10)."""
+
+import subprocess
+import sys
+
+from pathlib import Path
+
+from .input_handler import get_user_input
+from .template_handler import extract_template
+from .venv_handler import setup_venv, install_requirements
+from .config_handler import save_config
+from .logo_handler import handle_logo
+from .placeholder_handler import replace_all_placeholders
+
+
+def run(target_dir: str, config: dict | None = None) -> None:
+    """Execute the full init pipeline inside *target_dir*.
+
+    When *config* is provided the pipeline uses it directly (GUI mode)
+    and skips the interactive ``get_user_input()`` prompt.
+
+    Args:
+        target_dir: Absolute or relative path to the (empty) project directory.
+        config: Pre-collected configuration dict (from GUI). When ``None``
+            the pipeline prompts via terminal.
+    """
+    target = Path(target_dir).resolve()
+
+    if not target.is_dir():
+        print(f"  Creating directory: {target}")
+        target.mkdir(parents=True, exist_ok=True)
+
+    print("=" * 60)
+    print("  synapseForge — Init Pipeline")
+    print("=" * 60)
+
+    # Step 1: User input
+    if config is None:
+        print("\n[1/10] User input ...")
+        config = get_user_input()
+    else:
+        print("\n[1/10] Using provided configuration ...")
+
+    # Step 2: Download & extract template
+    print("\n[2/10] Downloading & extracting template ...")
+    extract_template(target)
+
+    # Step 3: Create virtual environment
+    print("\n[3/10] Creating virtual environment ...")
+    venv_path = setup_venv(target, config["repo"])
+
+    # Step 4: Install Python requirements
+    print("\n[4/10] Installing Python requirements ...")
+    install_requirements(venv_path, target)
+
+    # Step 5: npm install
+    print("\n[5/10] Installing npm dependencies ...")
+    _run_npm_install(target)
+
+    # Step 6: Copy logos
+    print("\n[6/10] Copying logos ...")
+    company_logo_dest = target / "frontend" / "src" / "assets" / "logo_empresa.png"
+    handle_logo(config, company_logo_dest, config_key="logo.path")
+    # Also copy to root/src for backward compatibility with template references
+    company_logo_root = target / "src" / "logo_empresa.png"
+    handle_logo(config, company_logo_root, config_key="logo.path")
+    client_logo_dest = target / "frontend" / "src" / "assets" / "logo_cliente.png"
+    handle_logo(config, client_logo_dest, config_key="logo_cliente")
+
+    # Step 7: Generate .ico from client logo
+    print("\n[7/10] Generating favicon (.ico) ...")
+    _run_generate_ico(venv_path, client_logo_dest)
+
+    # Step 8: Extract colors from client logo
+    print("\n[8/10] Resolving colors ...")
+    _resolve_colors(config, client_logo_dest)
+
+    # Step 9: Save user config (colors already in dict)
+    print("\n[9/10] Saving configuration ...")
+    save_config(target, config)
+
+    # Step 10: Replace placeholders
+    print("\n[10/10] Replacing placeholders ...")
+    replace_all_placeholders(target, config)
+
+    print("\n" + "=" * 60)
+    print("  Done! Project initialized in:", target)
+    print("=" * 60)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _run_npm_install(target: Path) -> None:
+    """Run ``npm install`` in the frontend directory."""
+    frontend_dir = target / "frontend"
+    if not (frontend_dir / "package.json").is_file():
+        print("  WARNING: package.json not found, skipping npm install")
+        return
+
+    try:
+        subprocess.run(
+            "npm install",
+            cwd=str(frontend_dir),
+            shell=True,
+            check=True,
+        )
+        print("  npm install completed")
+    except subprocess.CalledProcessError as exc:
+        print(f"  WARNING: npm install failed (exit code {exc.returncode})")
+    except FileNotFoundError:
+        print("  WARNING: npm not found, skipping npm install")
+
+
+def _run_generate_ico(venv_path: Path, logo_png: Path) -> None:
+    """Generate ``.ico`` from the logo PNG using Pillow (inline)."""
+    if not logo_png.is_file():
+        print("  WARNING: logo PNG not found, skipping .ico generation")
+        return
+
+    try:
+        from PIL import Image
+    except ImportError:
+        print("  WARNING: Pillow not available, skipping .ico generation")
+        return
+
+    ico_path = logo_png.with_suffix(".ico")
+    try:
+        img = Image.open(str(logo_png))
+        sizes = [(16, 16), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)]
+        img.save(str(ico_path), format="ICO", sizes=sizes)
+        print(f"  Generated: {ico_path}")
+    except Exception as exc:
+        print(f"  WARNING: .ico generation failed: {exc}")
+
+
+def _resolve_colors(config: dict, logo_png: Path) -> None:
+    """Validate that all 4 color fields exist in config."""
+    keys = ["primary", "secondary", "primary_text", "gradient_secondary"]
+    colors = config.setdefault("colors", {})
+    missing = [k for k in keys if not colors.get(k)]
+    if missing:
+        print(f"  WARNING: missing colors in config: {missing}")
+        return
+
+    for k in keys:
+        print(f"  {k}: {colors[k]}")
+    usar = colors.get("usar_gradiente", True)
+    print(f"  gradient: {'ON' if usar else 'OFF'}")

pipeline/init/placeholder_handler.py

@@ -0,0 +1,162 @@
+"""Step 9 — Replace every XML placeholder tag in the extracted template.
+
+Scans all text files under the target directory and replaces occurrences
+of ``<tag>value</tag>`` with the actual value from the user config.
+
+Supports nested tags such as ``<descripcion>...</descripcion>``,
+``<cliente>...</cliente>``, ``<color_primario>...</color_primario>``, etc.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, Pattern
+
+# ---------------------------------------------------------------------------
+# Tag → config key mapping
+# ---------------------------------------------------------------------------
+TAG_MAP: Dict[str, str] = {
+    "logo": "logo.path",
+    "empresa": "empresa",
+    "owner": "owner",
+    "legal": "legal",
+    "repo": "repo",
+    "cliente": "cliente",
+    "logo_cliente": "logo_cliente",
+    "descripcion": "descripcion",
+    "tarea": "tarea",
+    # Colors — 4 configurables + gradient toggle
+    "color_primario": "colors.primary",
+    "color_secundario": "colors.secondary",
+    "color_texto_primario": "colors.primary_text",
+    "color_secundario_gradiente": "colors.gradient_secondary",
+}
+
+# Regex that matches <tag>anything</tag>.  Tag names must be [a-z_]+.
+_TAG_RE: Pattern = re.compile(r"<([a-z_]+)>([^<]*)</\1>")
+
+
+def replace_all_placeholders(target: Path, config: dict) -> None:
+    """Walk the entire *target* tree and replace XML placeholders.
+
+    Only processes text-like files (extensions: .py, .tsx, .ts, .js, .jsx,
+    .html, .css, .md, .json, .txt, .yaml, .yml, .toml, .ini, .cfg, .env).
+
+    Args:
+        target: Project root directory.
+        config: User config dictionary.
+    """
+    replacements = _build_replacement_map(config)
+
+    # Track stats for final summary
+    modified_files = 0
+    total_replacements = 0
+
+    for file_path in target.rglob("*"):
+        if not file_path.is_file():
+            continue
+        if not _is_text_file(file_path):
+            continue
+
+        # Skip node_modules, .git, __pycache__, .venv
+        if _should_skip(file_path):
+            continue
+
+        try:
+            original = file_path.read_bytes()
+        except Exception:
+            continue  # skip binary or permission-denied
+
+        text = original.decode("utf-8", errors="replace")
+
+        new_text, count = _replace_tags(text, replacements)
+
+        if count > 0 and new_text != text:
+            file_path.write_bytes(new_text.encode("utf-8"))
+            modified_files += 1
+            total_replacements += count
+
+    print(f"  Replaced {total_replacements} placeholder(s) across {modified_files} file(s)")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _build_replacement_map(config: dict) -> Dict[str, str]:
+    """Flatten the nested config into ``{tag: value}``."""
+    replacements: Dict[str, str] = {}
+
+    for tag, key_path in TAG_MAP.items():
+        if tag == "logo":
+            # Path relativo al repo desde la raíz (el logo se copia a ambos lugares)
+            replacements[tag] = "src/logo_empresa.png"
+        else:
+            value = _deep_get(config, key_path)
+            if value is not None and value != "":
+                replacements[tag] = str(value)
+
+    return replacements
+
+
+def _deep_get(d: dict, dotted: str):
+    """Traverse a dict with a dotted path like ``colors.primary``."""
+    parts = dotted.split(".")
+    current: object = d
+    for part in parts:
+        if isinstance(current, dict):
+            current = current.get(part)
+        else:
+            return None
+    return current
+
+
+def _replace_tags(text: str, replacements: Dict[str, str]) -> tuple:
+    """Replace all ``<tag>...</tag>`` spans in *text* with the mapped value.
+
+    Returns ``(new_text, count)``.
+    """
+
+    def _replacer(m: re.Match) -> str:
+        tag = m.group(1)
+        if tag in replacements:
+            return replacements[tag]
+        # Unrecognised tag → leave untouched
+        return m.group(0)
+
+    new_text, count = _TAG_RE.subn(_replacer, text)
+    return new_text, count
+
+
+_TEXT_EXTENSIONS = frozenset({
+    ".py", ".tsx", ".ts", ".js", ".jsx",
+    ".html", ".css", ".md", ".json", ".txt",
+    ".yaml", ".yml", ".toml", ".ini", ".cfg",
+    ".env", ".env.example", ".gitignore",
+    ".ps1", ".bat", ".cmd", ".sh",
+})
+
+_NOEXT_NAMES = frozenset({
+    "LICENSE", "CHANGELOG", "CONTRIBUTORS",
+})
+
+_SKIP_DIRS = frozenset({
+    "node_modules", ".git", "__pycache__", ".venv",
+    ".synapseForge", ".vite", ".vite-temp",
+})
+
+
+def _is_text_file(path: Path) -> bool:
+    """Check extension against known text types."""
+    return (
+        path.suffix in _TEXT_EXTENSIONS
+        or path.name == ".gitignore"
+        or path.name in _NOEXT_NAMES
+    )
+
+
+def _should_skip(path: Path) -> bool:
+    """Return True if the path is inside a directory that should be skipped."""
+    for parent in path.parents:
+        if parent.name in _SKIP_DIRS:
+            return True
+    return False

pipeline/init/template_handler.py

@@ -0,0 +1,89 @@
+"""Step 2 — Locate bundled (or download) template.zip and extract into target."""
+
+import sys
+import urllib.request
+import zipfile
+from pathlib import Path
+from importlib.resources import files as resources_files
+
+# ---------------------------------------------------------------------------
+# URL used as fallback when the bundled zip is not available.
+# ---------------------------------------------------------------------------
+TEMPLATE_URL = (
+    "https://github.com/synapse-ai-hub/synapseForge/raw/main/pipeline/template.zip"
+)
+
+
+def extract_template(target: Path) -> None:
+    """Extract the template zip into *target*.
+
+    Looks for a bundled copy first (from pip install or development mode),
+    otherwise downloads from the GitHub raw URL.
+
+    The bundled zip inside the installed package is **never** deleted so
+    that every invocation stays offline-capable.
+    """
+    bundled = _get_bundled_zip()
+    was_downloaded = False
+
+    if bundled is not None and bundled.is_file():
+        zip_path = bundled
+        print(f"  Using bundled template: {zip_path}")
+    else:
+        zip_path = _download_template(target)
+        if zip_path is None:
+            print("  ERROR: could not obtain template.zip")
+            sys.exit(1)
+        was_downloaded = True
+
+    _safe_extract(zip_path, target)
+
+    # Only delete the zip if it was the downloaded copy —
+    # never touch the bundled copy inside site-packages.
+    if was_downloaded:
+        zip_path.unlink(missing_ok=True)
+
+    print(f"  Extracted to: {target}")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_bundled_zip() -> Path | None:
+    """Locate the ``template.zip`` shipped inside the ``pipeline`` package.
+
+    Works both in development mode (``pip install -e .``) and when installed
+    from PyPI — the file lives in the ``pipeline`` directory of the package.
+    """
+    try:
+        return Path(resources_files("pipeline").joinpath("template.zip"))  # type: ignore[arg-type]
+    except (ModuleNotFoundError, TypeError):
+        return None
+
+
+def _download_template(target: Path) -> Path | None:
+    """Download template.zip from GitHub into *target*."""
+    try:
+        dest = target / "template.zip"
+        print("  Downloading template from GitHub …")
+        urllib.request.urlretrieve(TEMPLATE_URL, dest)
+        print(f"  Downloaded: {dest}")
+        return dest
+    except Exception as exc:
+        print(f"  Download failed: {exc}")
+        return None
+
+
+def _safe_extract(zip_path: Path, target: Path) -> None:
+    """Extract zip, overwriting existing files silently."""
+    try:
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            zf.extractall(path=target)
+    except zipfile.BadZipFile:
+        print(f"  ERROR: corrupted zip file: {zip_path}")
+        sys.exit(1)
+    except Exception as exc:
+        print(f"  ERROR extracting zip: {exc}")
+        sys.exit(1)

pipeline/init/venv_handler.py

@@ -0,0 +1,68 @@
+"""Steps 3-4 — Create virtual environment and install dependencies."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def setup_venv(target: Path, repo_name: str) -> Path:
+    """Create a Python virtual environment at ``{target}/.{repo_name}``.
+
+    Args:
+        target: Project root directory.
+        repo_name: Used as the venv folder name (``.{{repo_name}}``).
+
+    Returns:
+        Path to the venv root.
+    """
+    venv_dir = target / f".{repo_name}"
+    if venv_dir.is_dir():
+        print(f"  Virtual env already exists: {venv_dir}")
+        return venv_dir
+
+    result = subprocess.run(
+        [sys.executable, "-m", "venv", str(venv_dir)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"  ERROR creating venv: {result.stderr.strip()}")
+        sys.exit(1)
+
+    print(f"  Created: {venv_dir}")
+    return venv_dir
+
+
+def install_requirements(venv_path: Path, target: Path) -> None:
+    """Run ``pip install -r requirements.txt`` inside the venv.
+
+    Args:
+        venv_path: Path to the virtual environment root.
+        target: Project root (where ``requirements.txt`` lives).
+    """
+    req_file = target / "requirements.txt"
+    if not req_file.is_file():
+        print("  WARNING: requirements.txt not found, skipping install")
+        return
+
+    python = _venv_python(venv_path)
+    result = subprocess.run(
+        [str(python), "-m", "pip", "install", "-r", str(req_file)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"  WARNING: pip install failed:\n{result.stderr.strip()}")
+        return
+
+    # Print last line of pip output (usually "Successfully installed ...")
+    last_line = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else ""
+    if last_line:
+        print(f"  {last_line}")
+    else:
+        print("  Requirements installed.")
+
+
+def _venv_python(venv_path: Path) -> Path:
+    """Return the path to the venv's Python executable."""
+    return venv_path / "Scripts" / "python.exe"