docspecbridge 0.2.0b1__py3-none-any.whl

docspecbridge/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0b1"

docspecbridge/cli.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+
+from . import __version__
+from .config import confluence_instances, load_config
+from .config_ui import config_menu
+from .confluence import list_spaces, publish
+from .doctor import doctor_info
+from .extractor import run_extract
+
+
+app = typer.Typer(add_completion=False, no_args_is_help=False, help="DocSpecBridge - document ETL bridge")
+console = Console()
+
+
+def _cfg(config: Optional[Path]):
+    return load_config(config)
+
+
+def _apply_overwrite(cfg: dict, overwrite: bool) -> None:
+    if overwrite:
+        cfg["app"]["overwrite"] = True
+
+
+def _select_instance(cfg: dict, default: str | None = None) -> str:
+    names = list(confluence_instances(cfg))
+    if not names:
+        raise RuntimeError("Aucune instance Confluence configurée. Utiliser le menu Configuration YAML.")
+    if len(names) == 1:
+        return names[0]
+    default_name = default or str(cfg.get("confluence", {}).get("default_instance") or names[0])
+    for idx, name in enumerate(names, 1):
+        marker = " *" if name == default_name else ""
+        console.print(f"[{idx}] {name}{marker}")
+    default_idx = str(names.index(default_name) + 1) if default_name in names else "1"
+    idx = int(Prompt.ask("Instance Confluence", default=default_idx))
+    return names[idx - 1]
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context) -> None:
+    """Sans sous-commande, ouvre le menu interactif."""
+    if ctx.invoked_subcommand is None:
+        menu()
+
+
+@app.command()
+def extract(
+    source: Annotated[Optional[Path], typer.Option("--source", "-s", help="Fichier ou répertoire source")] = None,
+    dest: Annotated[Optional[Path], typer.Option("--dest", "-d", help="Répertoire de destination")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c", help="YAML de configuration")] = None,
+    overwrite: Annotated[bool, typer.Option("--overwrite", help="Autoriser la réécriture des packages existants")] = False,
+) -> None:
+    """Extrait DOCX/PDF/PPTX vers publication Markdown + RAG + images."""
+    cfg = _cfg(config)
+    _apply_overwrite(cfg, overwrite)
+    source = source or Path(cfg["app"]["source"])
+    dest = dest or Path(cfg["app"]["destination"])
+    outcomes = run_extract(cfg, source, dest)
+
+    table = Table(title="Extraction DocSpecBridge")
+    table.add_column("Source")
+    table.add_column("Etat")
+    table.add_column("Images", justify="right")
+    table.add_column("Package")
+    for item in outcomes:
+        state = f"ERROR: {item.error}" if item.error else ("WARNING" if item.warnings else "OK")
+        table.add_row(item.source.name, state, str(len(item.images)), str(item.package_dir))
+        for warning in item.warnings:
+            console.print(f"[yellow]  ! {item.source.name}: {warning}[/yellow]")
+    console.print(table)
+    if not outcomes:
+        console.print("[yellow]Aucun fichier correspondant aux extensions configurées.[/yellow]")
+    if any(item.error for item in outcomes):
+        raise typer.Exit(2)
+
+
+@app.command("spaces")
+def spaces_cmd(
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Nom d'instance Confluence YAML")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c")] = None,
+) -> None:
+    """Liste les espaces Confluence Cloud visibles pour une instance."""
+    cfg = _cfg(config)
+    selected = instance or _select_instance(cfg)
+    spaces = list_spaces(cfg, selected)
+    table = Table(title=f"Espaces Confluence - {selected}")
+    table.add_column("Key")
+    table.add_column("Name")
+    table.add_column("ID")
+    for space in spaces:
+        table.add_row(str(space.get("key", "")), str(space.get("name", "")), str(space.get("id", "")))
+    console.print(table)
+
+
+@app.command("publish")
+def publish_cmd(
+    source: Annotated[Path, typer.Option("--source", "-s", help="Package, corpus ou fichier .md")],
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Nom d'instance Confluence YAML")] = None,
+    space: Annotated[Optional[str], typer.Option("--space", help="Clé espace Confluence")] = None,
+    parent: Annotated[Optional[str], typer.Option("--parent", help="Page ID parent/root")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c")] = None,
+) -> None:
+    """Publie les Markdown publication dans Confluence Cloud avec leurs images inline."""
+    cfg = _cfg(config)
+    selected = instance or _select_instance(cfg)
+    published = publish(cfg, source, space_key=space, root_page=parent, instance_name=selected)
+    console.print(f"[green]{len(published)} page(s) traitée(s) par md2conf sur {selected}.[/green]")
+
+
+app.command("import-confluence")(publish_cmd)
+
+
+@app.command("config")
+def config_cmd(
+    config: Annotated[Optional[Path], typer.Option("--config", "-c")] = None,
+) -> None:
+    """Ouvre le petit éditeur interactif du YAML DocSpecBridge."""
+    config_menu(config)
+
+
+@app.command()
+def doctor(
+    config: Annotated[Optional[Path], typer.Option("--config", "-c")] = None,
+) -> None:
+    """Affiche versions, proxy et instances/token Confluence."""
+    cfg = _cfg(config)
+    table = Table(title="DocSpecBridge doctor")
+    table.add_column("Elément")
+    table.add_column("Valeur")
+    for key, value in doctor_info(cfg).items():
+        table.add_row(key, value)
+    console.print(table)
+
+
+def menu() -> None:
+    console.print(f"\n[bold cyan]DocSpecBridge {__version__}[/bold cyan]")
+    console.print("Document ETL: Office/PDF -> publication + RAG -> Confluence Cloud\n")
+    while True:
+        console.print("[1] Extract")
+        console.print("[2] Import Confluence")
+        console.print("[3] Lister les espaces Confluence")
+        console.print("[4] Doctor")
+        console.print("[5] Configuration YAML")
+        console.print("[0] Quitter")
+        choice = Prompt.ask("Action", choices=["0", "1", "2", "3", "4", "5"], default="1")
+        try:
+            if choice == "0":
+                return
+            if choice == "1":
+                cfg = load_config()
+                source = Path(Prompt.ask("Source", default=str(cfg["app"]["source"])))
+                dest = Path(Prompt.ask("Destination", default=str(cfg["app"]["destination"])))
+                outcomes = run_extract(cfg, source, dest)
+                for item in outcomes:
+                    if item.error:
+                        console.print(f"[red]ERROR[/red] {item.source}: {item.error}")
+                    else:
+                        console.print(f"[green]OK[/green] {item.source.name} -> {item.package_dir} ({len(item.images)} image(s))")
+                        for warning in item.warnings:
+                            console.print(f"[yellow]  ! {warning}[/yellow]")
+            elif choice == "2":
+                cfg = load_config()
+                selected = _select_instance(cfg)
+                source = Path(Prompt.ask("Package/corpus à publier", default=str(cfg["app"]["destination"])))
+                spaces = list_spaces(cfg, selected)
+                for idx, item in enumerate(spaces, start=1):
+                    console.print(f"[{idx}] {item.get('key', '')} - {item.get('name', '')}")
+                selected_space = int(Prompt.ask("Numéro espace"))
+                space = str(spaces[selected_space - 1].get("key"))
+                instance_cfg = confluence_instances(cfg)[selected]
+                default_parent = str(instance_cfg.get("root_page") or "")
+                parent = Prompt.ask("Page ID parent (vide = accueil espace)", default=default_parent).strip() or None
+                pages = publish(cfg, source, space_key=space, root_page=parent, instance_name=selected)
+                console.print(f"[green]{len(pages)} page(s) publiée(s)/synchronisée(s) sur {selected}.[/green]")
+            elif choice == "3":
+                cfg = load_config()
+                selected = _select_instance(cfg)
+                for item in list_spaces(cfg, selected):
+                    console.print(f"{item.get('key', ''):15} {item.get('name', '')}")
+            elif choice == "4":
+                cfg = load_config()
+                for key, value in doctor_info(cfg).items():
+                    console.print(f"{key:30} {value}")
+            elif choice == "5":
+                config_menu()
+        except Exception as exc:
+            console.print(f"[red]Erreur: {exc}[/red]")
+        console.print()

docspecbridge/config.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "app": {
+        "source": "./input",
+        "destination": "./output",
+        "extensions": [".docx", ".pdf", ".pptx"],
+        "recursive": True,
+        "preserve_source_tree": True,
+        "copy_source": True,
+        "overwrite": False,
+    },
+    "extract": {
+        "engine": "xberg",
+        "use_cache": True,
+        "enable_quality_processing": True,
+        "output_format": "markdown",
+        "extraction_timeout_secs": 600,
+        "images": {
+            "extract_images": True,
+            "target_dpi": 300,
+            "max_image_dimension": 4096,
+            "auto_adjust_dpi": True,
+            "inject_placeholders": True,
+            "include_data_base64": True,
+            "run_ocr_on_images": False,
+        },
+        "deduplicate_assets": True,
+        "docx_layout": {
+            "include_header_images_once": True,
+            "include_footer_images_once": False,
+        },
+        "pdf_layout": {
+            "collapse_repeated_images": True,
+            "repeat_threshold": 3,
+        },
+        "pdf_options": {
+            "extract_images": True,
+            "extract_tables": True,
+            "extract_metadata": True,
+        },
+        "diagnostics": {
+            "inspect_ooxml": True,
+            "warn_on_unresolved_images": True,
+            "keep_raw_xberg_markdown": True,
+        },
+    },
+    "profiles": {
+        "publication": {
+            "enabled": True,
+            "preserve_image_display_size": True,
+            "display_image_directory": "publication_images",
+            "min_display_px": 12,
+            "max_display_px": 1800,
+            "avoid_upscale": False,
+            "preserve_formatting": True,
+        },
+        "rag": {
+            "enabled": True,
+            "write_descriptor": True,
+            "keep_image_references": True,
+            "include_header_images": False,
+            "include_footer_images": False,
+            "collapse_repeated_images": True,
+            "token_reduction": "off",
+            "chunking": {
+                "enabled": True,
+                "max_characters": 1600,
+                "overlap": 150,
+                "prepend_heading_context": True,
+            },
+        },
+    },
+    "confluence": {
+        "default_instance": "",
+        "instances": {},
+        "layout": {
+            "image_alignment": "center",
+            "image_max_width": 1600,
+            "table_display_mode": "responsive",
+        },
+        "keep_hierarchy": False,
+        "overwrite_manual_changes": False,
+        "write_page_id_to_markdown": False,
+        "render_mermaid": False,
+    },
+}
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = deepcopy(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(result.get(key), dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _migrate_legacy(data: dict[str, Any]) -> dict[str, Any]:
+    data = deepcopy(data)
+
+    # 0.1.x had a top-level `rag` section.
+    legacy_rag = data.pop("rag", None)
+    if isinstance(legacy_rag, dict):
+        profiles = data.setdefault("profiles", {})
+        profiles["rag"] = _deep_merge(profiles.get("rag", {}), legacy_rag)
+
+    # 0.1.x described one Confluence endpoint directly under `confluence`.
+    cf = data.get("confluence")
+    if isinstance(cf, dict) and not cf.get("instances"):
+        legacy_keys = {
+            "domain",
+            "base_path",
+            "api_url",
+            "user_name",
+            "token_env",
+            "api_version",
+            "default_space",
+            "root_page",
+        }
+        if any(cf.get(key) not in (None, "") for key in legacy_keys):
+            instance = {key: cf.get(key) for key in legacy_keys if key in cf}
+            instance.setdefault("base_path", "/wiki/")
+            instance.setdefault("token_env", "ATLASSIAN_API_TOKEN")
+            instance.setdefault("api_version", "v2")
+            cf["instances"] = {"default": instance}
+            cf["default_instance"] = cf.get("default_instance") or "default"
+        for key in legacy_keys:
+            cf.pop(key, None)
+    return data
+
+
+def find_default_config() -> Path | None:
+    for name in ("docspecbridge.yaml", "docspecbridge.yml", "config.yaml", "config.yml"):
+        path = Path.cwd() / name
+        if path.is_file():
+            return path
+    return None
+
+
+def selected_config_path(path: Path | None = None) -> Path:
+    return (path or find_default_config() or (Path.cwd() / "docspecbridge.yaml")).resolve()
+
+
+def load_config(path: Path | None = None) -> dict[str, Any]:
+    selected = path or find_default_config()
+    if selected is None:
+        return deepcopy(DEFAULT_CONFIG)
+    with selected.open("r", encoding="utf-8") as handle:
+        data = yaml.safe_load(handle) or {}
+    if not isinstance(data, dict):
+        raise ValueError(f"Configuration YAML invalide: {selected}")
+    return _deep_merge(DEFAULT_CONFIG, _migrate_legacy(data))
+
+
+def save_config(config: dict[str, Any], path: Path | None = None) -> Path:
+    selected = selected_config_path(path)
+    selected.parent.mkdir(parents=True, exist_ok=True)
+    selected.write_text(
+        yaml.safe_dump(config, allow_unicode=True, sort_keys=False, width=120),
+        encoding="utf-8",
+    )
+    return selected
+
+
+def init_config(path: Path | None = None, *, overwrite: bool = False) -> Path:
+    selected = selected_config_path(path)
+    if selected.exists() and not overwrite:
+        return selected
+    return save_config(deepcopy(DEFAULT_CONFIG), selected)
+
+
+def confluence_instances(config: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    cf = config.get("confluence") or {}
+    instances = cf.get("instances") or {}
+    return {str(name): dict(value or {}) for name, value in instances.items()}
+
+
+def get_confluence_instance(config: dict[str, Any], name: str | None = None) -> tuple[str, dict[str, Any]]:
+    cf = config.get("confluence") or {}
+    instances = confluence_instances(config)
+    selected = (name or cf.get("default_instance") or "").strip()
+    if not selected:
+        if len(instances) == 1:
+            selected = next(iter(instances))
+        else:
+            raise RuntimeError("Aucune instance Confluence sélectionnée et confluence.default_instance est vide.")
+    if selected not in instances:
+        raise RuntimeError(f"Instance Confluence inconnue: {selected}")
+    instance = _deep_merge(
+        {
+            "domain": "",
+            "base_path": "/wiki/",
+            "api_url": "",
+            "user_name": "",
+            "token_env": "ATLASSIAN_API_TOKEN",
+            "api_version": "v2",
+            "default_space": "",
+            "root_page": "",
+        },
+        instances[selected],
+    )
+    # DocSpecBridge 0.2 targets Cloud only.
+    instance["api_version"] = "v2"
+    return selected, instance

docspecbridge/config_ui.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from .config import confluence_instances, init_config, load_config, save_config, selected_config_path
+
+
+console = Console()
+
+
+def _show_summary(cfg: dict[str, Any], path: Path) -> None:
+    table = Table(title=f"Configuration DocSpecBridge - {path}")
+    table.add_column("Clé")
+    table.add_column("Valeur")
+    app = cfg["app"]
+    pub = cfg["profiles"]["publication"]
+    rag = cfg["profiles"]["rag"]
+    cf = cfg["confluence"]
+    table.add_row("app.source", str(app.get("source")))
+    table.add_row("app.destination", str(app.get("destination")))
+    table.add_row("app.extensions", ", ".join(app.get("extensions") or []))
+    table.add_row("app.recursive", str(bool(app.get("recursive"))))
+    table.add_row("publication.preserve_image_display_size", str(bool(pub.get("preserve_image_display_size"))))
+    table.add_row("rag.enabled", str(bool(rag.get("enabled"))))
+    table.add_row("rag.chunking.enabled", str(bool((rag.get("chunking") or {}).get("enabled"))))
+    table.add_row("confluence.default_instance", str(cf.get("default_instance") or ""))
+    table.add_row("confluence.instances", ", ".join(confluence_instances(cfg)) or "(aucune)")
+    console.print(table)
+
+
+def _edit_app(cfg: dict[str, Any]) -> None:
+    app = cfg["app"]
+    app["source"] = Prompt.ask("Source par défaut", default=str(app.get("source") or "./input"))
+    app["destination"] = Prompt.ask("Destination par défaut", default=str(app.get("destination") or "./output"))
+    ext_default = ",".join(app.get("extensions") or [".docx", ".pdf", ".pptx"])
+    extensions = Prompt.ask("Extensions (séparées par des virgules)", default=ext_default)
+    app["extensions"] = [e.strip().lower() if e.strip().startswith(".") else "." + e.strip().lower() for e in extensions.split(",") if e.strip()]
+    app["recursive"] = Confirm.ask("Recherche récursive", default=bool(app.get("recursive", True)))
+    app["preserve_source_tree"] = Confirm.ask(
+        "Conserver l'arborescence source", default=bool(app.get("preserve_source_tree", True))
+    )
+    app["copy_source"] = Confirm.ask("Copier le fichier source dans le package", default=bool(app.get("copy_source", True)))
+
+
+def _edit_profiles(cfg: dict[str, Any]) -> None:
+    profiles = cfg["profiles"]
+    pub = profiles["publication"]
+    rag = profiles["rag"]
+    pub["enabled"] = Confirm.ask("Générer le Markdown publication", default=bool(pub.get("enabled", True)))
+    pub["preserve_image_display_size"] = Confirm.ask(
+        "Préserver la taille d'affichage des images", default=bool(pub.get("preserve_image_display_size", True))
+    )
+    rag["enabled"] = Confirm.ask("Générer le profil RAG", default=bool(rag.get("enabled", True)))
+    rag["keep_image_references"] = Confirm.ask(
+        "Conserver les références images dans rag.md", default=bool(rag.get("keep_image_references", True))
+    )
+    rag["include_header_images"] = Confirm.ask(
+        "Conserver les images de header dans rag.md", default=bool(rag.get("include_header_images", False))
+    )
+    chunking = rag.setdefault("chunking", {})
+    chunking["enabled"] = Confirm.ask("Générer chunks.jsonl", default=bool(chunking.get("enabled", True)))
+    if chunking["enabled"]:
+        chunking["max_characters"] = int(Prompt.ask("Taille max chunk (caractères)", default=str(chunking.get("max_characters", 1600))))
+        chunking["overlap"] = int(Prompt.ask("Overlap (caractères)", default=str(chunking.get("overlap", 150))))
+
+
+def _list_instances(cfg: dict[str, Any]) -> None:
+    instances = confluence_instances(cfg)
+    default_name = str((cfg.get("confluence") or {}).get("default_instance") or "")
+    table = Table(title="Instances Confluence Cloud")
+    table.add_column("Nom")
+    table.add_column("Défaut")
+    table.add_column("Domaine")
+    table.add_column("Utilisateur")
+    table.add_column("Token env")
+    table.add_column("Espace")
+    for name, item in instances.items():
+        table.add_row(
+            name,
+            "*" if name == default_name else "",
+            str(item.get("domain") or item.get("api_url") or ""),
+            str(item.get("user_name") or "Bearer"),
+            str(item.get("token_env") or "ATLASSIAN_API_TOKEN"),
+            str(item.get("default_space") or ""),
+        )
+    console.print(table)
+
+
+def _edit_instance(cfg: dict[str, Any]) -> None:
+    cf = cfg.setdefault("confluence", {})
+    instances = cf.setdefault("instances", {})
+    current_names = list(instances)
+    default_name = current_names[0] if current_names else "production"
+    name = Prompt.ask("Nom logique de l'instance", default=default_name).strip()
+    current = dict(instances.get(name) or {})
+    current["domain"] = Prompt.ask("Domaine Cloud (ex: company.atlassian.net)", default=str(current.get("domain") or ""))
+    current["base_path"] = "/wiki/"
+    current["api_url"] = Prompt.ask(
+        "API URL Atlassian scoped token (optionnel, vide pour domaine classique)",
+        default=str(current.get("api_url") or ""),
+    ).strip()
+    current["user_name"] = Prompt.ask(
+        "Email Atlassian (vide = Bearer/scoped token)", default=str(current.get("user_name") or "")
+    ).strip()
+    current["token_env"] = Prompt.ask("Variable d'environnement du token", default=str(current.get("token_env") or "ATLASSIAN_API_TOKEN")).strip()
+    current["api_version"] = "v2"
+    current["default_space"] = Prompt.ask("Espace par défaut (optionnel)", default=str(current.get("default_space") or "")).strip()
+    current["root_page"] = Prompt.ask("Page racine ID (optionnel)", default=str(current.get("root_page") or "")).strip()
+    instances[name] = current
+    if not cf.get("default_instance"):
+        cf["default_instance"] = name
+
+
+def _instances_menu(cfg: dict[str, Any]) -> None:
+    while True:
+        console.print("\n[1] Lister")
+        console.print("[2] Ajouter / modifier")
+        console.print("[3] Définir l'instance par défaut")
+        console.print("[4] Supprimer")
+        console.print("[0] Retour")
+        choice = Prompt.ask("Action Confluence", choices=["0", "1", "2", "3", "4"], default="1")
+        if choice == "0":
+            return
+        if choice == "1":
+            _list_instances(cfg)
+        elif choice == "2":
+            _edit_instance(cfg)
+        elif choice == "3":
+            names = list(confluence_instances(cfg))
+            if not names:
+                console.print("[yellow]Aucune instance définie.[/yellow]")
+                continue
+            for idx, name in enumerate(names, 1):
+                console.print(f"[{idx}] {name}")
+            idx = int(Prompt.ask("Numéro", default="1"))
+            cfg["confluence"]["default_instance"] = names[idx - 1]
+        elif choice == "4":
+            names = list(confluence_instances(cfg))
+            if not names:
+                continue
+            for idx, name in enumerate(names, 1):
+                console.print(f"[{idx}] {name}")
+            idx = int(Prompt.ask("Numéro à supprimer"))
+            name = names[idx - 1]
+            if Confirm.ask(f"Supprimer {name} ?", default=False):
+                cfg["confluence"]["instances"].pop(name, None)
+                if cfg["confluence"].get("default_instance") == name:
+                    cfg["confluence"]["default_instance"] = next(iter(cfg["confluence"]["instances"]), "")
+
+
+def config_menu(path: Path | None = None) -> Path:
+    config_path = selected_config_path(path)
+    if not config_path.exists():
+        if Confirm.ask(f"Créer {config_path} ?", default=True):
+            init_config(config_path)
+    cfg = load_config(config_path) if config_path.exists() else load_config(None)
+
+    while True:
+        console.print("\n[bold cyan]Configuration YAML[/bold cyan]")
+        console.print("[1] Afficher le résumé")
+        console.print("[2] Source / destination / extensions")
+        console.print("[3] Profils publication / RAG")
+        console.print("[4] Instances Confluence Cloud")
+        console.print("[5] Sauvegarder")
+        console.print("[0] Sauvegarder et retour")
+        choice = Prompt.ask("Action", choices=["0", "1", "2", "3", "4", "5"], default="1")
+        if choice == "1":
+            _show_summary(cfg, config_path)
+        elif choice == "2":
+            _edit_app(cfg)
+        elif choice == "3":
+            _edit_profiles(cfg)
+        elif choice == "4":
+            _instances_menu(cfg)
+        elif choice == "5":
+            save_config(cfg, config_path)
+            console.print(f"[green]Sauvegardé: {config_path}[/green]")
+        elif choice == "0":
+            save_config(cfg, config_path)
+            console.print(f"[green]Sauvegardé: {config_path}[/green]")
+            return config_path