@danhachuel/thunderbolt 0.2.13

package/hermes_ui/blueprints.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .storage import BLUEPRINTS, now
+
+
+def _slug(value: str) -> str:
+    value = re.sub(r"[^a-zA-Z0-9À-ÿ]+", "-", value.strip().lower()).strip("-")
+    return value or "canal"
+
+
+def parse_youtube_link(url: str) -> dict[str, str]:
+    value = url.strip()
+    if not value:
+        raise ValueError("Introduza um link do YouTube.")
+    video_id = ""
+    channel_ref = ""
+    input_type = "channel"
+    if "youtu.be/" in value:
+        video_id = value.split("youtu.be/", 1)[1].split("?", 1)[0].split("/", 1)[0]
+        input_type = "video"
+    elif "watch?v=" in value:
+        video_id = value.split("watch?v=", 1)[1].split("&", 1)[0]
+        input_type = "video"
+    elif "/shorts/" in value:
+        video_id = value.split("/shorts/", 1)[1].split("?", 1)[0].split("/", 1)[0]
+        input_type = "video"
+    elif "/@" in value:
+        channel_ref = value.split("/@", 1)[1].split("/", 1)[0].split("?", 1)[0]
+        input_type = "channel_handle"
+    elif "/channel/" in value:
+        channel_ref = value.split("/channel/", 1)[1].split("/", 1)[0].split("?", 1)[0]
+        input_type = "channel_id"
+    else:
+        channel_ref = value.rstrip("/").split("/")[-1].lstrip("@")
+        input_type = "channel_handle"
+    return {"original_url": value, "video_id": video_id, "channel_ref": channel_ref, "input_type": input_type}
+
+
+def create_blueprint_from_link(url: str, niche: str, language: str, include_branding: bool, channel_name: str = "") -> tuple[dict[str, Any], dict[str, Any] | None]:
+    parsed = parse_youtube_link(url)
+    base_name = channel_name.strip() or parsed["channel_ref"] or "Canal analisado"
+    timestamp = datetime.now(timezone.utc).isoformat()
+    blueprint_id = f"bp_{uuid.uuid4().hex[:10]}"
+    blueprint = {
+        "id": blueprint_id,
+        "name": f"Blueprint — {base_name}",
+        "metadata": {
+            "task_type": "forensic_content_blueprint",
+            "source_url": parsed["original_url"],
+            "input_type": parsed["input_type"],
+            "video_id": parsed["video_id"],
+            "channel_ref": parsed["channel_ref"],
+            "target_niche": niche or "não definido",
+            "language": language,
+            "created_at": timestamp,
+            "status": "draft_local",
+        },
+        "channel_profile": {
+            "channel_name": base_name,
+            "handle": f"@{parsed['channel_ref']}" if parsed["channel_ref"] else "",
+            "description": "Preencher com dados importados do YouTube e análise forense.",
+            "audience": "",
+            "content_pillars": [],
+        },
+        "content_strategy": {
+            "niche": niche or "",
+            "format": "faceless",
+            "publishing_frequency": "",
+            "hook_patterns": [],
+            "title_formulas": [],
+            "script_structure": ["hook", "context", "development", "payoff", "cta"],
+            "full_script_target_characters": "7000-9000",
+        },
+        "research": {
+            "top_videos": [],
+            "sample_video": {},
+            "transcripts": [],
+            "source_notes": [],
+        },
+        "branding_id": "",
+        "version": 1,
+    }
+    branding = None
+    if include_branding:
+        branding = create_branding_for_blueprint(blueprint)
+        blueprint["branding_id"] = branding["id"]
+    return blueprint, branding
+
+
+def create_branding_for_blueprint(blueprint: dict[str, Any]) -> dict[str, Any]:
+    metadata = blueprint.get("metadata", {})
+    channel = blueprint.get("channel_profile", {})
+    name = channel.get("channel_name") or blueprint.get("name", "Canal").replace("Blueprint — ", "")
+    branding = {
+        "id": f"branding_{uuid.uuid4().hex[:10]}",
+        "name": f"Branding — {name}",
+        "blueprint_id": blueprint.get("id", ""),
+        "source_url": metadata.get("source_url", ""),
+        "created_at": now(),
+        "status": "draft_local",
+        "identity": {
+            "channel_name": name,
+            "handle": channel.get("handle", ""),
+            "tagline": "",
+            "description": channel.get("description", ""),
+            "hashtags": [],
+            "keywords": [],
+        },
+        "visual_identity": {
+            "color_palette": [],
+            "typography": {"primary": "", "secondary": ""},
+            "profile_image_prompt": f"Logo de perfil para o canal faceless {name}, nicho {metadata.get('target_niche', '')}, visual memorável, sem texto pequeno.",
+            "banner_prompt": f"Banner de YouTube para {name}, nicho {metadata.get('target_niche', '')}, composição cinematográfica, espaço seguro para texto.",
+            "thumbnail_direction": "alto contraste, uma ideia visual principal, máximo quatro palavras",
+        },
+        "assets": {
+            "profile_image": "",
+            "banner": "",
+            "watermark": "",
+            "brand_pack_path": "",
+        },
+        "checklist": {
+            "name_reviewed": False,
+            "handle_reviewed": False,
+            "description_reviewed": False,
+            "profile_prompt_reviewed": False,
+            "banner_prompt_reviewed": False,
+            "assets_generated": False,
+        },
+        "version": 1,
+    }
+    return branding
+
+
+def save_generated_blueprint(blueprint: dict[str, Any], branding: dict[str, Any] | None = None) -> tuple[Path, Path | None]:
+    BLUEPRINTS.mkdir(parents=True, exist_ok=True)
+    target = BLUEPRINTS / "canais" / f"{_slug(blueprint.get('name', 'blueprint'))}-{blueprint['id']}.json"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(__import__("json").dumps(blueprint, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    branding_path = None
+    if branding:
+        branding_path = BLUEPRINTS / "brandings" / f"{_slug(branding.get('name', 'branding'))}-{branding['id']}.json"
+        branding_path.parent.mkdir(parents=True, exist_ok=True)
+        branding_path.write_text(__import__("json").dumps(branding, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return target, branding_path
+
+
+def list_branding_files() -> list[Path]:
+    folder = BLUEPRINTS / "brandings"
+    folder.mkdir(parents=True, exist_ok=True)
+    return sorted(folder.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

package/hermes_ui/domain.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import re
+import uuid
+from typing import Any
+
+from .storage import append_json, now, read_json, write_json
+
+STAGES = ["niche", "blueprint", "brand", "script", "title", "thumbnail", "video", "edit", "upload"]
+VALID_STATES = {"to_do", "doing", "blocked", "done", "failed", "cancelled"}
+
+
+def slugify(value: str) -> str:
+    value = re.sub(r"[^a-zA-Z0-9À-ÿ]+", "-", value.strip().lower()).strip("-")
+    return value or "item"
+
+
+def make_id(prefix: str) -> str:
+    return f"{prefix}_{uuid.uuid4().hex[:10]}"
+
+
+def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = None) -> dict[str, Any]:
+    channel = {
+        "id": make_id("channel"),
+        "name": name.strip(),
+        "url": url.strip(),
+        "handle": "",
+        "description": "",
+        "thumbnail_url": "",
+        "subscriber_count": None,
+        "video_count": None,
+        "view_count": None,
+        "metrics_source": "manual",
+        "last_youtube_sync": None,
+        "language": "Português",
+        "blueprint_id": "",
+        "style_wide": "pexels",
+        "voice": "",
+        "active": True,
+        "daily_limit": 1,
+        "backlog_total": 0,
+        "created_at": now(),
+        "updated_at": now(),
+    }
+    if metadata:
+        channel.update({k: v for k, v in metadata.items() if k in channel})
+    channels = read_json("channels.json", [])
+    channels.append(channel)
+    write_json("channels.json", channels)
+    return channel
+
+
+def update_channel(channel_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    channels = read_json("channels.json", [])
+    for channel in channels:
+        if channel.get("id") == channel_id:
+            channel.update(updates)
+            channel["updated_at"] = now()
+            write_json("channels.json", channels)
+            return channel
+    return None
+
+
+def create_batch(mode: str, channel_ids: list[str], topic: str, quantity: int, options: dict[str, Any]) -> dict[str, Any]:
+    batch = {
+        "id": make_id("batch"),
+        "mode": mode,
+        "channel_ids": channel_ids,
+        "topic": topic.strip(),
+        "quantity": quantity,
+        "status": "to_do",
+        "created_at": now(),
+        "options": options,
+    }
+    append_json("batches.json", batch)
+    return batch
+
+
+def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
+    tasks = read_json("tasks.json", [])
+    channels = {c["id"]: c for c in read_json("channels.json", [])}
+    target_channels = batch["channel_ids"]
+    count = batch["quantity"]
+    if batch["mode"] == "general":
+        count = 1
+    created: list[dict[str, Any]] = []
+    for channel_id in target_channels:
+        for index in range(count):
+            channel = channels.get(channel_id, {})
+            task = {
+                "id": make_id("video"),
+                "batch_id": batch["id"],
+                "creation_mode": batch["mode"],
+                "channel_id": channel_id,
+                "channel_name": channel.get("name", "Canal"),
+                "topic": batch["topic"] if count == 1 else f"{batch['topic']} — variação {index + 1}",
+                "language": batch["options"].get("language", channel.get("language", "Português")),
+                "format": batch["options"].get("format", "wide"),
+                "style_wide": batch["options"].get("style_wide", channel.get("style_wide", "pexels")),
+                "stage": "script",
+                "state": "to_do",
+                "progress": 0,
+                "artifacts": {},
+                "error": None,
+                "created_at": now(),
+                "updated_at": now(),
+            }
+            tasks.append(task)
+            created.append(task)
+    write_json("tasks.json", tasks)
+    for task in created:
+        queues = read_json("queues.json", {})
+        queues.setdefault("script", []).append(task["id"])
+        write_json("queues.json", queues)
+    return created
+
+
+def transition_task(task_id: str, state: str | None = None, stage: str | None = None, error: str | None = None) -> dict[str, Any] | None:
+    if state and state not in VALID_STATES:
+        raise ValueError(f"Estado inválido: {state}")
+    tasks = read_json("tasks.json", [])
+    for task in tasks:
+        if task.get("id") == task_id:
+            if state:
+                task["state"] = state
+            if stage:
+                if stage not in STAGES:
+                    raise ValueError(f"Etapa inválida: {stage}")
+                task["stage"] = stage
+            if error is not None:
+                task["error"] = error
+            task["updated_at"] = now()
+            write_json("tasks.json", tasks)
+            return task
+    return None
+
+
+def pipeline_summary() -> dict[str, Any]:
+    tasks = read_json("tasks.json", [])
+    channels = read_json("channels.json", [])
+    return {
+        "channels": len(channels),
+        "active_channels": sum(1 for c in channels if c.get("active")),
+        "total_tasks": len(tasks),
+        "done": sum(1 for t in tasks if t.get("state") == "done"),
+        "pending": sum(1 for t in tasks if t.get("state") in {"to_do", "doing", "blocked"}),
+        "failed": sum(1 for t in tasks if t.get("state") == "failed"),
+        "doing": sum(1 for t in tasks if t.get("state") == "doing"),
+    }

package/hermes_ui/metadata_cleaner.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import unicodedata
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import storage
+
+
+def _metadata_root() -> Path:
+    return storage.STORAGE / "metadata_cleaner"
+
+
+def _originals() -> Path:
+    return _metadata_root() / "originals"
+
+
+def _outputs() -> Path:
+    return _metadata_root() / "outputs"
+
+VIDEO_EXTENSIONS = ["mp4", "mov", "mkv", "webm", "avi", "m4v", "mpeg", "mpg"]
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _safe_filename(name: str) -> str:
+    normalized = unicodedata.normalize("NFKD", Path(name).name)
+    ascii_name = normalized.encode("ascii", "ignore").decode("ascii")
+    ascii_name = re.sub(r"[^A-Za-z0-9._-]+", "-", ascii_name).strip(".-")
+    return ascii_name or "video-terceiro.mp4"
+
+
+def _ensure_directories() -> None:
+    _originals().mkdir(parents=True, exist_ok=True)
+    _outputs().mkdir(parents=True, exist_ok=True)
+
+
+def store_external_video(filename: str, content: bytes) -> tuple[Path, str]:
+    """Persist an uploaded third-party video by content hash without overwriting it."""
+    if not content:
+        raise ValueError("O ficheiro de vídeo está vazio.")
+    _ensure_directories()
+    digest = hashlib.sha256(content).hexdigest()
+    safe_name = _safe_filename(filename)
+    path = _originals() / f"{digest[:16]}-{safe_name}"
+    if not path.exists():
+        path.write_bytes(content)
+    return path, digest
+
+
+def _resolve_ffmpeg(configured_path: str | None = None) -> str:
+    configured = (configured_path or "").strip()
+    if configured:
+        candidate = Path(configured).expanduser()
+        if candidate.is_file():
+            return str(candidate)
+        resolved = shutil.which(configured)
+        if resolved:
+            return resolved
+    resolved = shutil.which("ffmpeg")
+    if resolved:
+        return resolved
+    try:
+        import imageio_ffmpeg
+
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except Exception as exc:  # pragma: no cover - depends on local installation
+        raise RuntimeError("FFmpeg não foi encontrado. Instale-o ou configure o caminho em Configurações.") from exc
+
+
+def build_description(preview: str, links: str, timestamps: str) -> str:
+    """Match the n8n workflow's preview + links + timestamps description format."""
+    sections: list[str] = []
+    if preview.strip():
+        sections.append(preview.strip())
+    if links.strip():
+        link_lines = links.strip()
+        if not link_lines.lower().startswith("links:"):
+            link_lines = "Links:\n" + link_lines
+        sections.append(link_lines)
+    if timestamps.strip():
+        sections.append(timestamps.strip())
+    return "\n\n".join(sections).strip()
+
+
+def normalize_tags(tags: str | list[str]) -> list[str]:
+    if isinstance(tags, list):
+        values = tags
+    else:
+        values = re.split(r"[,;\n]", tags)
+    result: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        cleaned = re.sub(r"^#+", "", str(value).strip())
+        if cleaned and cleaned.lower() not in seen:
+            result.append(cleaned)
+            seen.add(cleaned.lower())
+    return result
+
+
+def _ffmpeg_metadata_args(metadata: dict[str, Any]) -> list[str]:
+    args: list[str] = ["-map_metadata", "-1"]
+    mapping = {
+        "title": "title",
+        "description": "description",
+        "comment": "comment",
+        "language": "language",
+        "creator": "artist",
+        "copyright": "copyright",
+        "date": "date",
+        "genre": "genre",
+        "album": "album",
+    }
+    for field, ffmpeg_key in mapping.items():
+        value = str(metadata.get(field, "") or "").strip()
+        if value:
+            args.extend(["-metadata", f"{ffmpeg_key}={value}"])
+    tags = normalize_tags(metadata.get("tags", ""))
+    if tags:
+        args.extend(["-metadata", f"keywords={', '.join(tags)}"])
+        args.extend(["-metadata", f"synopsis={', '.join(tags)}"])
+    return args
+
+
+def clean_video_metadata(
+    source: Path,
+    metadata: dict[str, Any],
+    *,
+    ffmpeg_path: str | None = None,
+) -> tuple[Path, dict[str, Any]]:
+    """Strip existing container metadata and write a clean third-party copy."""
+    if not source.is_file():
+        raise FileNotFoundError("O vídeo externo não foi encontrado no armazenamento local.")
+    _ensure_directories()
+    ffmpeg = _resolve_ffmpeg(ffmpeg_path)
+    source_name = _safe_filename(source.name)
+    output = _outputs() / f"limpo-{datetime.now().strftime('%Y%m%d-%H%M%S')}-{source_name}"
+    command = [ffmpeg, "-y", "-hide_banner", "-loglevel", "error", "-i", str(source)]
+    command.extend(_ffmpeg_metadata_args(metadata))
+    command.extend(["-c", "copy", str(output)])
+    completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    if completed.returncode != 0 or not output.exists() or output.stat().st_size == 0:
+        if output.exists():
+            output.unlink()
+        detail = (completed.stderr or completed.stdout or "erro desconhecido").strip()
+        raise RuntimeError(f"FFmpeg não conseguiu limpar os metadados: {detail[-1200:]}")
+    return output, {
+        "ffmpeg": ffmpeg,
+        "command": command,
+        "source": str(source),
+        "output": str(output),
+        "created_at": _now(),
+    }
+
+
+def save_edit_record(source: Path, output: Path, metadata: dict[str, Any], run_info: dict[str, Any]) -> dict[str, Any]:
+    tags = normalize_tags(metadata.get("tags", ""))
+    record = {
+        "id": hashlib.sha256(f"{source}:{output}".encode("utf-8")).hexdigest()[:16],
+        "source_type": "third_party_video",
+        "source_name": source.name,
+        "source_path": str(source),
+        "output_name": output.name,
+        "output_path": str(output),
+        "metadata": {**metadata, "tags": tags},
+        "run": {key: value for key, value in run_info.items() if key != "command"},
+        "created_at": run_info.get("created_at", _now()),
+    }
+    storage.append_json("metadata_edits.json", record)
+    return record
+
+
+def list_edit_records() -> list[dict[str, Any]]:
+    records = storage.read_json("metadata_edits.json", [])
+    if not isinstance(records, list):
+        return []
+    return list(reversed(records))
+
+
+def metadata_manifest(record: dict[str, Any]) -> bytes:
+    """Return a portable JSON sidecar for YouTube title/description/tags upload."""
+    return (json.dumps(record, ensure_ascii=False, indent=2) + "\n").encode("utf-8")