devflow-cli 1.0.0__py3-none-any.whl

devflow_cli/commands/upgrade_cmd.py

@@ -0,0 +1,142 @@
+"""devflow upgrade — Detection et mise a jour des templates obsoletes."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import typer
+
+from devflow_cli import VERSION
+from devflow_cli.core.manifest import (
+    compute_source_manifest,
+    load_manifest,
+    save_manifest,
+    compare_manifests,
+    compute_file_hash,
+)
+from devflow_cli.utils.console import console, ok, info, warn, fail, header
+from devflow_cli.utils.paths import get_devflow_root, get_claude_dir
+
+
+def upgrade(
+    dry_run: bool = typer.Option(False, "--dry-run", help="Affiche le rapport sans modifier"),
+    force: bool = typer.Option(False, "--force", help="Met a jour sans confirmation"),
+) -> None:
+    """Detecte et met a jour les templates devflow obsoletes."""
+    claude_dir = get_claude_dir()
+
+    if not claude_dir.is_dir():
+        fail("Aucun template installe. Lancez `devflow init` d'abord.")
+        raise typer.Exit(1)
+
+    templates_dir = claude_dir / "templates"
+    if not templates_dir.is_dir():
+        fail("Aucun template installe. Lancez `devflow init` d'abord.")
+        raise typer.Exit(1)
+
+    # Calculer le manifeste source
+    devflow_root = get_devflow_root()
+    source_manifest = compute_source_manifest(devflow_root)
+
+    # Charger le manifeste d'installation
+    installed_manifest = load_manifest(claude_dir)
+    if installed_manifest is None:
+        info("Pas de manifeste d'installation (installation legacy).")
+        info("Comparaison par checksums directs.")
+
+    # Comparer
+    statuses = compare_manifests(source_manifest, installed_manifest, claude_dir)
+
+    if not statuses:
+        info("Aucun template a verifier.")
+        return
+
+    # Afficher le rapport
+    header("devflow upgrade — Rapport de templates")
+    console.print()
+
+    from devflow_cli.utils.console import make_table
+    table = make_table("Template", "Statut", title="Templates")
+
+    status_icons = {
+        "current": "[green]a jour[/green]",
+        "outdated": "[yellow]obsolete[/yellow]",
+        "modified": "[red]modifie local[/red]",
+        "new": "[blue]nouveau[/blue]",
+        "unknown": "[dim]inconnu[/dim]",
+    }
+
+    outdated = [s for s in statuses if s.status == "outdated"]
+    modified = [s for s in statuses if s.status == "modified"]
+    new_templates = [s for s in statuses if s.status == "new"]
+    current = [s for s in statuses if s.status == "current"]
+    unknown = [s for s in statuses if s.status == "unknown"]
+
+    for s in statuses:
+        table.add_row(s.path, status_icons.get(s.status, s.status))
+
+    console.print(table)
+    console.print()
+    console.print(
+        f"Resume : {len(current)} a jour, {len(outdated)} obsoletes, "
+        f"{len(modified)} modifies, {len(new_templates)} nouveaux"
+        + (f", {len(unknown)} inconnus" if unknown else "")
+    )
+
+    # Version warning
+    if installed_manifest and installed_manifest.get("devflow_version", "") > VERSION:
+        warn(f"La version installee ({installed_manifest['devflow_version']}) est plus recente que la source ({VERSION}).")
+
+    # Rien a faire ?
+    to_update = outdated + new_templates
+    if not to_update and not modified:
+        console.print()
+        ok("Tous les templates sont a jour.")
+        return
+
+    if dry_run:
+        console.print()
+        console.print("[dim]Mode dry-run : aucun fichier modifie.[/dim]")
+        return
+
+    # Mise a jour des templates obsoletes et nouveaux
+    if to_update:
+        if not force:
+            console.print()
+            if not typer.confirm(f"Mettre a jour {len(to_update)} template(s) ?", default=True):
+                console.print("Annule.")
+                return
+
+        for s in to_update:
+            src = devflow_root / s.path
+            dest = claude_dir / s.path
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dest)
+            ok(f"  {s.path}")
+
+    # Templates modifies localement
+    if modified:
+        console.print()
+        warn(f"{len(modified)} template(s) modifie(s) localement :")
+        for s in modified:
+            console.print(f"  [red]{s.path}[/red]")
+
+        if force or typer.confirm("Ecraser les templates modifies ? (sauvegarde .bak)", default=False):
+            for s in modified:
+                src = devflow_root / s.path
+                dest = claude_dir / s.path
+                bak = dest.with_suffix(dest.suffix + ".bak")
+                shutil.copy2(dest, bak)
+                shutil.copy2(src, dest)
+                ok(f"  {s.path} (ancien -> {bak.name})")
+        else:
+            info("Templates modifies ignores.")
+
+    # Mettre a jour le manifeste
+    new_manifest = compute_source_manifest(devflow_root)
+    new_manifest["installed_at"] = new_manifest.pop("computed_at")
+    save_manifest(claude_dir, new_manifest)
+
+    console.print()
+    ok("Mise a jour terminee. Manifeste actualise.")

devflow_cli/core/catalog.py

@@ -0,0 +1,101 @@
+"""Lecture multi-catalogue JSON pour les extensions devflow."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from devflow_cli.utils.paths import get_devflow_root, get_claude_dir
+
+
+@dataclass
+class ExtensionInclude:
+    type: str
+    file: str
+    target: str
+
+
+@dataclass
+class Extension:
+    name: str
+    description: str
+    type: str
+    version: str
+    includes: list[ExtensionInclude]
+    source: str = "principal"  # principal | communaute | distant
+
+
+@dataclass
+class Catalog:
+    version: str
+    extensions: list[Extension]
+    source: str = "principal"
+
+
+def load_catalog(path: Path, source: str = "principal") -> Catalog | None:
+    """Charge un fichier catalogue JSON."""
+    if not path.is_file():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        from devflow_cli.utils.console import warn
+        warn(f"Catalogue corrompu ou illisible : {path} ({type(e).__name__}: {e})")
+        return None
+
+    extensions = []
+    for ext_data in data.get("extensions", []):
+        includes = [
+            ExtensionInclude(**inc) for inc in ext_data.get("includes", [])
+        ]
+        extensions.append(Extension(
+            name=ext_data["name"],
+            description=ext_data.get("description", ""),
+            type=ext_data.get("type", "bundle"),
+            version=ext_data.get("version", "0.0.0"),
+            includes=includes,
+            source=source,
+        ))
+    return Catalog(version=data.get("version", "1.0.0"), extensions=extensions, source=source)
+
+
+def load_all_catalogs() -> list[Catalog]:
+    """Charge tous les catalogues disponibles (principal, communautaire, distant)."""
+    root = get_devflow_root()
+    catalogs: list[Catalog] = []
+
+    # Principal
+    principal = load_catalog(root / "extensions" / "catalog.json", "principal")
+    if principal:
+        catalogs.append(principal)
+
+    # Communautaire
+    community = load_catalog(root / "extensions" / "catalog.community.json", "communaute")
+    if community and community.extensions:
+        catalogs.append(community)
+
+    # Catalogue distant : non implémenté (voir future feature)
+
+    return catalogs
+
+
+def find_extension(name: str, catalogs: list[Catalog] | None = None) -> Extension | None:
+    """Cherche une extension par nom dans tous les catalogues."""
+    if catalogs is None:
+        catalogs = load_all_catalogs()
+    for catalog in catalogs:
+        for ext in catalog.extensions:
+            if ext.name == name:
+                return ext
+    return None
+
+
+def is_installed(ext: Extension) -> bool:
+    """Verifie si tous les fichiers d'une extension sont installes."""
+    claude_dir = get_claude_dir()
+    for inc in ext.includes:
+        filename = Path(inc.file).name
+        if not (claude_dir / inc.target / filename).is_file():
+            return False
+    return True

devflow_cli/core/git.py

@@ -0,0 +1,68 @@
+"""Operations git pour devflow."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+class GitNotFoundError(Exception):
+    """Levee quand git n'est pas installe ou pas dans le PATH."""
+
+    def __init__(self) -> None:
+        super().__init__("git n'est pas installé ou n'est pas dans le PATH")
+
+
+_git_checked = False
+
+
+def ensure_git_available() -> None:
+    """Verifie que git est accessible. Leve GitNotFoundError sinon."""
+    global _git_checked  # noqa: PLW0603
+    if _git_checked:
+        return
+    try:
+        subprocess.run(
+            ["git", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        _git_checked = True
+    except FileNotFoundError:
+        raise GitNotFoundError() from None
+
+
+def _run(args: list[str], cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    ensure_git_available()
+    return subprocess.run(args, capture_output=True, text=True, cwd=cwd)
+
+
+def is_git_repo(path: Path | None = None) -> bool:
+    """Verifie si le repertoire est un depot git."""
+    result = _run(["git", "rev-parse", "--is-inside-work-tree"], cwd=path)
+    return result.returncode == 0
+
+
+def branch_exists(branch: str, cwd: Path | None = None) -> bool:
+    """Verifie si une branche locale existe."""
+    result = _run(["git", "show-ref", "--verify", "--quiet", f"refs/heads/{branch}"], cwd=cwd)
+    return result.returncode == 0
+
+
+def create_branch(branch: str, cwd: Path | None = None) -> bool:
+    """Cree et checkout une nouvelle branche."""
+    result = _run(["git", "checkout", "-b", branch], cwd=cwd)
+    return result.returncode == 0
+
+
+def checkout_branch(branch: str, cwd: Path | None = None) -> bool:
+    """Checkout une branche existante."""
+    result = _run(["git", "checkout", branch], cwd=cwd)
+    return result.returncode == 0
+
+
+def current_branch(cwd: Path | None = None) -> str:
+    """Retourne le nom de la branche courante."""
+    result = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+    return result.stdout.strip() if result.returncode == 0 else ""

devflow_cli/core/hooks.py

@@ -0,0 +1,89 @@
+"""Validation de fichiers devflow-hooks.yml."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+VALID_HOOK_POINTS = {"after_tasks", "before_implement", "after_implement"}
+VALID_HOOK_TYPES = {"shell", "claude", "agent"}
+
+
+@dataclass
+class ValidationResult:
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    ok_messages: list[str] = field(default_factory=list)
+
+    @property
+    def is_valid(self) -> bool:
+        return len(self.errors) == 0
+
+
+def validate_hooks_file(hooks_file: Path) -> ValidationResult:
+    """Valide la syntaxe et les references d'un fichier devflow-hooks.yml."""
+    result = ValidationResult()
+
+    if not hooks_file.is_file():
+        result.errors.append(f"Fichier de hooks non trouve : {hooks_file}")
+        return result
+
+    try:
+        data = yaml.safe_load(hooks_file.read_text(encoding="utf-8"))
+    except yaml.YAMLError as e:
+        result.errors.append(f"Erreur de syntaxe YAML : {e}")
+        return result
+
+    if not isinstance(data, dict) or "hooks" not in data:
+        result.errors.append("Le fichier doit contenir une cle 'hooks' a la racine")
+        return result
+
+    hooks = data.get("hooks")
+    if hooks is None:
+        # hooks: sans contenu = valide (tout commente)
+        return result
+
+    if not isinstance(hooks, dict):
+        result.errors.append("'hooks' doit etre un dictionnaire")
+        return result
+
+    for hook_point, entries in hooks.items():
+        # Verifier le hook point
+        if hook_point not in VALID_HOOK_POINTS:
+            result.errors.append(
+                f"Hook point inconnu : '{hook_point}' (valides: {', '.join(sorted(VALID_HOOK_POINTS))})"
+            )
+        else:
+            result.ok_messages.append(f"Hook point : {hook_point}")
+
+        if not isinstance(entries, list):
+            result.errors.append(f"'{hook_point}' doit etre une liste")
+            continue
+
+        for entry in entries:
+            if not isinstance(entry, dict):
+                result.errors.append(f"Chaque hook doit etre un dictionnaire (dans {hook_point})")
+                continue
+
+            # Verifier le type
+            hook_type = entry.get("type", "")
+            if hook_type not in VALID_HOOK_TYPES:
+                result.errors.append(
+                    f"Type de hook inconnu : '{hook_type}' (valides: {', '.join(sorted(VALID_HOOK_TYPES))})"
+                )
+
+            # Verifier la presence de command
+            if "command" not in entry:
+                result.warnings.append(f"Hook sans champ 'command' dans {hook_point}")
+
+            # Verifier format commande claude
+            if hook_type == "claude":
+                cmd = entry.get("command", "")
+                first_word = cmd.split()[0] if cmd.split() else ""
+                if first_word and not first_word.startswith("/"):
+                    result.warnings.append(f"Commande claude sans '/' : {cmd}")
+
+    return result

devflow_cli/core/installer.py

@@ -0,0 +1,139 @@
+"""Installation devflow et gestion des extensions."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from devflow_cli.core.catalog import Extension
+from devflow_cli.utils.paths import get_devflow_root, get_claude_dir
+
+
+@dataclass
+class CopyResult:
+    copied: int = 0
+    skipped: int = 0
+
+
+def _copy_files(src_dir: Path, dest_dir: Path, pattern: str, force: bool = False) -> CopyResult:
+    """Copie les fichiers correspondant au pattern."""
+    result = CopyResult()
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    for f in sorted(src_dir.glob(pattern)):
+        if not f.is_file():
+            continue
+        dest = dest_dir / f.name
+        if force or not dest.exists():
+            shutil.copy2(f, dest)
+            result.copied += 1
+        else:
+            result.skipped += 1
+    return result
+
+
+def install_devflow(force: bool = False, script_type: str | None = None) -> dict[str, CopyResult]:
+    """Installe commandes, agents, templates et scripts dans ~/.claude/.
+
+    Args:
+        force: Ecraser les fichiers existants.
+        script_type: Filtrer les scripts par type ("bash", "powershell", ou None pour tous).
+    """
+    root = get_devflow_root()
+    claude = get_claude_dir()
+    results: dict[str, CopyResult] = {}
+
+    # Commandes
+    results["commands"] = _copy_files(root / "commands", claude / "commands", "devflow*.md", force)
+
+    # Agents
+    results["agents"] = _copy_files(root / "agents", claude / "agents", "devflow*.md", force)
+
+    # Templates (fichiers racine)
+    results["templates"] = _copy_files(root / "templates", claude / "templates", "*", force)
+
+    # Templates export
+    if (root / "templates" / "export").is_dir():
+        r = _copy_files(root / "templates" / "export", claude / "templates" / "export", "*", force)
+        results["templates"].copied += r.copied
+        results["templates"].skipped += r.skipped
+
+    # Templates checklists
+    if (root / "templates" / "checklists").is_dir():
+        r = _copy_files(root / "templates" / "checklists", claude / "templates" / "checklists", "*", force)
+        results["templates"].copied += r.copied
+        results["templates"].skipped += r.skipped
+
+    # Templates contracts
+    if (root / "templates" / "contracts").is_dir():
+        r = _copy_files(root / "templates" / "contracts", claude / "templates" / "contracts", "*", force)
+        results["templates"].copied += r.copied
+        results["templates"].skipped += r.skipped
+
+    # Scripts — filtrage par script_type
+    if script_type == "bash":
+        extensions = ("*.sh",)
+    elif script_type == "powershell":
+        extensions = ("*.ps1",)
+    else:
+        extensions = ("*.sh", "*.ps1")
+
+    scripts_result = CopyResult()
+    scripts_dir = root / "scripts"
+    dest_scripts = claude / "scripts"
+    dest_scripts.mkdir(parents=True, exist_ok=True)
+    for ext in extensions:
+        for f in sorted(scripts_dir.glob(ext)):
+            if not f.is_file():
+                continue
+            dest = dest_scripts / f.name
+            if force or not dest.exists():
+                shutil.copy2(f, dest)
+                if f.suffix == ".sh":
+                    dest.chmod(dest.stat().st_mode | 0o111)
+                scripts_result.copied += 1
+            else:
+                scripts_result.skipped += 1
+    results["scripts"] = scripts_result
+
+    return results
+
+
+def install_extension(ext: Extension) -> CopyResult:
+    """Installe une extension (copie ses fichiers vers ~/.claude/)."""
+    root = get_devflow_root()
+    claude = get_claude_dir()
+    result = CopyResult()
+
+    for inc in ext.includes:
+        src = root / inc.file
+        filename = Path(inc.file).name
+        dest_dir = claude / inc.target
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        dest = dest_dir / filename
+
+        if not src.is_file():
+            continue
+
+        if dest.exists():
+            result.skipped += 1
+        else:
+            shutil.copy2(src, dest)
+            result.copied += 1
+
+    return result
+
+
+def uninstall_extension(ext: Extension) -> int:
+    """Desinstalle une extension (supprime ses fichiers de ~/.claude/)."""
+    claude = get_claude_dir()
+    removed = 0
+
+    for inc in ext.includes:
+        filename = Path(inc.file).name
+        dest = claude / inc.target / filename
+        if dest.is_file():
+            dest.unlink()
+            removed += 1
+
+    return removed