devflow-cli 1.0.0__py3-none-any.whl

devflow_cli/commands/extension.py

@@ -0,0 +1,137 @@
+"""devflow extension — Gestion des extensions devflow."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from devflow_cli.core.catalog import (
+    load_all_catalogs,
+    find_extension,
+    is_installed,
+    Extension,
+)
+from devflow_cli.core.installer import install_extension, uninstall_extension
+from devflow_cli.utils.console import console, ok, warn, fail, make_table
+
+app = typer.Typer(help="Gestion des extensions devflow")
+
+
+@app.command("list")
+def list_extensions() -> None:
+    """Liste les extensions avec statut d'installation."""
+    catalogs = load_all_catalogs()
+
+    if not catalogs:
+        fail("Aucun catalogue trouve.")
+        raise typer.Exit(1)
+
+    table = make_table("Statut", "Source", "Nom", "Fichiers", "Description", title="Extensions devflow")
+
+    for catalog in catalogs:
+        for ext in catalog.extensions:
+            status = "[green]installe[/green]" if is_installed(ext) else "[dim]non installe[/dim]"
+            source = f"[yellow]{ext.source}[/yellow]" if ext.source != "principal" else ext.source
+            table.add_row(
+                status,
+                source,
+                ext.name,
+                str(len(ext.includes)),
+                ext.description,
+            )
+
+    console.print(table)
+
+
+@app.command()
+def search(term: str = typer.Argument(..., help="Terme de recherche")) -> None:
+    """Recherche dans le catalogue (principal + communautaire)."""
+    catalogs = load_all_catalogs()
+    term_lower = term.lower()
+
+    console.print(f"Recherche : '{term}'")
+    console.print()
+
+    found = False
+    for catalog in catalogs:
+        for ext in catalog.extensions:
+            if term_lower in ext.name.lower() or term_lower in ext.description.lower():
+                source_label = f" [yellow][{ext.source}][/yellow]" if ext.source != "principal" else ""
+                console.print(f"  {ext.name}{source_label} — {ext.description}")
+                found = True
+
+    if not found:
+        console.print("  Aucun resultat.")
+
+
+@app.command()
+def add(name: str = typer.Argument(..., help="Nom de l'extension a installer")) -> None:
+    """Installe une extension."""
+    catalogs = load_all_catalogs()
+    ext = find_extension(name, catalogs)
+
+    if ext is None:
+        fail(f"Extension '{name}' non trouvee dans aucun catalogue.")
+        console.print("Utilisez 'devflow extension catalog' pour voir les extensions disponibles.")
+        raise typer.Exit(1)
+
+    source_label = f" [{ext.source}]" if ext.source != "principal" else ""
+    console.print(f"Installation de '{name}'{source_label}...")
+    console.print()
+
+    result = install_extension(ext)
+
+    for inc in ext.includes:
+        filename = inc.file.split("/")[-1]
+        console.print(f"  [green][ok][/green]   {inc.target}/{filename}")
+
+    console.print()
+    console.print(f"Termine : {result.copied} copies, {result.skipped} ignores")
+
+
+@app.command()
+def remove(name: str = typer.Argument(..., help="Nom de l'extension a desinstaller")) -> None:
+    """Desinstalle une extension."""
+    catalogs = load_all_catalogs()
+    ext = find_extension(name, catalogs)
+
+    if ext is None:
+        fail(f"Extension '{name}' non trouvee dans le catalogue.")
+        raise typer.Exit(1)
+
+    console.print(f"Suppression de '{name}'...")
+    console.print()
+
+    removed = uninstall_extension(ext)
+
+    for inc in ext.includes:
+        filename = inc.file.split("/")[-1]
+        console.print(f"  [green][ok][/green]  supprime {inc.target}/{filename}")
+
+    console.print()
+    console.print(f"Termine : {removed} fichiers supprimes")
+
+
+@app.command()
+def catalog() -> None:
+    """Affiche le catalogue complet."""
+    catalogs = load_all_catalogs()
+
+    if not catalogs:
+        fail("Aucun catalogue trouve.")
+        raise typer.Exit(1)
+
+    for cat in catalogs:
+        label = cat.source.capitalize()
+        console.rule(f"[bold]Catalogue devflow — {label}[/bold]")
+        console.print()
+
+        for ext in cat.extensions:
+            console.print(f"Extension : [bold]{ext.name}[/bold] v{ext.version}")
+            console.print(f"  Type     : {ext.type}")
+            console.print(f"  Desc     : {ext.description}")
+            console.print(f"  Fichiers :")
+            for inc in ext.includes:
+                console.print(f"    - {inc.type}: {inc.file}")
+            console.print()

devflow_cli/commands/feature.py

@@ -0,0 +1,102 @@
+"""devflow feature — Initialise une feature (branche + state.json)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from devflow_cli.core.git import branch_exists, create_branch, checkout_branch, GitNotFoundError
+from devflow_cli.core.state import create_state
+from devflow_cli.utils.console import console, ok, info
+from devflow_cli.utils.paths import get_specs_root, next_feature_number
+
+
+def _clean_short_name(name: str) -> str:
+    """Nettoie un short-name pour usage comme nom de repertoire."""
+    cleaned = name.lower()
+    cleaned = re.sub(r"[^a-z0-9]", "-", cleaned)
+    cleaned = re.sub(r"-+", "-", cleaned)
+    return cleaned.strip("-")
+
+
+def _validate_issue_id(issue_id: str) -> None:
+    """Valide que l'issue_id contient au moins un caractere alphanumerique."""
+    if not issue_id or not issue_id.strip() or not re.search(r"[a-zA-Z0-9]", issue_id):
+        console.print("[red]Erreur : identifiant de feature invalide (vide ou sans caractère alphanumérique).[/red]")
+        raise typer.Exit(1)
+
+
+def _ensure_git() -> None:
+    """Verifie que git est disponible, sinon affiche erreur et quitte."""
+    try:
+        from devflow_cli.core.git import ensure_git_available
+        ensure_git_available()
+    except GitNotFoundError as e:
+        console.print(f"[red]Erreur : {e}[/red]")
+        raise typer.Exit(1)
+
+
+def _init_feature_files(feature_dir: Path, issue_id: str) -> None:
+    """Cree state.json et review-log.md dans le dossier feature."""
+    state_file = feature_dir / "state.json"
+    if state_file.is_file():
+        console.print("  state.json existe deja, pas d'ecrasement.")
+    else:
+        create_state(state_file, issue_id)
+        ok("state.json initialise")
+
+    review_log = feature_dir / "review-log.md"
+    if review_log.is_file():
+        console.print("  review-log.md existe deja.")
+    else:
+        review_log.write_text(
+            f"# Review Log — {issue_id}\n\n"
+            f"> Journal des reviews de la feature {issue_id}\n\n---\n",
+            encoding="utf-8",
+        )
+        ok("review-log.md cree")
+
+
+def feature(
+    issue_id: str = typer.Argument(..., help="Identifiant de l'issue (ex: KS-123)"),
+    short_name: Optional[str] = typer.Option(None, "--short-name", help="Nom court pour le repertoire (ex: user-auth)"),
+) -> None:
+    """Initialise une feature : branche git + state.json + review-log.md."""
+    _validate_issue_id(issue_id)
+    _ensure_git()
+
+    name = _clean_short_name(short_name) if short_name else _clean_short_name(issue_id)
+    num = next_feature_number()
+    feature_name = f"{num:03d}-{name}"
+    branch = feature_name
+    feature_dir = get_specs_root() / feature_name
+
+    # Branche
+    if branch_exists(branch):
+        info(f"La branche {branch} existe deja, switch dessus.")
+        checkout_branch(branch)
+    else:
+        info(f"Creation de la branche {branch}...")
+        if not create_branch(branch):
+            console.print(f"[red]Erreur lors de la creation de la branche {branch}[/red]")
+            raise typer.Exit(1)
+
+    # Dossier feature
+    if feature_dir.is_dir():
+        console.print(f"  Le dossier {feature_dir} existe deja.")
+    else:
+        feature_dir.mkdir(parents=True)
+        ok(f"Dossier {feature_dir} cree")
+
+    _init_feature_files(feature_dir, issue_id)
+
+    console.print()
+    console.print(f"Feature [bold]{issue_id}[/bold] initialisee :")
+    console.print(f"  Branche : {branch}")
+    console.print(f"  Dossier : {feature_dir}/")
+    console.print(f"  Etat    : spec (etape initiale)")
+    console.print()
+    console.print(f"Prochaine etape : /devflow {issue_id}")

devflow_cli/commands/init_cmd.py

@@ -0,0 +1,94 @@
+"""devflow init — Installe devflow dans ~/.claude/ et initialise le projet."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Literal, Optional
+
+import typer
+
+from devflow_cli import SUPPORTED_AGENTS
+from devflow_cli.core.installer import install_devflow
+from devflow_cli.core.git import is_git_repo
+from devflow_cli.utils.console import console, ok, fail, warn, header
+from devflow_cli.core.manifest import compute_source_manifest, save_manifest
+from devflow_cli.utils.paths import get_devflow_root, get_claude_dir
+
+
+def init(
+    path: Optional[Path] = typer.Argument(None, help="Projet cible"),
+    force: bool = typer.Option(False, "--force", help="Ecraser les fichiers existants"),
+    with_constitution: bool = typer.Option(False, "--with-constitution", help="Creer une constitution starter"),
+    here: bool = typer.Option(False, "--here", help="Initialiser dans le repertoire courant"),
+    script: Optional[Literal["bash"]] = typer.Option(None, "--script", help="Type de scripts (bash)"),
+    ai: str = typer.Option("claude-code", "--ai", help="Agent IA cible"),
+) -> None:
+    """Installe devflow (commandes, agents, templates, scripts)."""
+    # Validation --here vs path
+    if here and path is not None:
+        fail("Les options --here et un chemin explicite sont mutuellement exclusifs.")
+        raise typer.Exit(1)
+
+    if here or path is None:
+        path = Path(".")
+
+    target = path.resolve()
+
+    if not is_git_repo(target):
+        fail(f"{target} n'est pas un depot git.")
+        raise typer.Exit(1)
+
+    # Validation --ai
+    if ai not in SUPPORTED_AGENTS:
+        warn(f"Agent '{ai}' non supporte. Agents reconnus : {', '.join(SUPPORTED_AGENTS)}. Installation avec defaults claude-code.")
+
+    header(f"devflow init — {target}")
+    console.print()
+
+    results = install_devflow(force=force, script_type=script)
+
+    for category, result in results.items():
+        label = category.ljust(10)
+        console.print(f"  {label}: {result.copied} copies, {result.skipped} ignores")
+
+    # Resume des options
+    if script:
+        console.print(f"  Scripts  : {script} uniquement")
+    if ai != "claude-code":
+        console.print(f"  Agent    : {ai} (defaults claude-code appliques)")
+
+    # Structure projet
+    specs_dir = target / ".specify" / "specs"
+    if not specs_dir.exists():
+        specs_dir.mkdir(parents=True)
+        ok(".specify/specs/ cree")
+    else:
+        console.print("  Structure : .specify/specs/ existe deja")
+
+    # Constitution optionnelle
+    if with_constitution:
+        const_dest = target / ".specify" / "memory" / "constitution.md"
+        const_src = get_devflow_root() / "templates" / "constitution-template.md"
+        if force or not const_dest.exists():
+            if const_src.is_file():
+                const_dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(const_src, const_dest)
+                ok("Constitution creee dans .specify/memory/constitution.md")
+            else:
+                fail("Template constitution non trouve")
+        else:
+            console.print("  Constitution : .specify/memory/constitution.md existe deja (--force pour ecraser)")
+
+    # Manifeste d'installation
+    try:
+        devflow_root = get_devflow_root()
+        manifest_data = compute_source_manifest(devflow_root)
+        manifest_data["installed_at"] = manifest_data.pop("computed_at")
+        save_manifest(get_claude_dir(), manifest_data)
+        ok("Manifeste d'installation cree")
+    except Exception:
+        warn("Impossible de creer le manifeste d'installation")
+
+    console.print()
+    console.print("[green]Installation terminee.[/green]")

devflow_cli/commands/migrate_cmd.py

@@ -0,0 +1,106 @@
+"""devflow migrate — Migration interactive des features legacy."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import typer
+
+from devflow_cli.core.state import read_state
+from devflow_cli.utils.console import console, ok, info, warn, fail, header
+from devflow_cli.utils.paths import get_specs_root, next_feature_number
+
+
+def _clean_short_name(name: str) -> str:
+    """Nettoie un short-name pour usage comme nom de repertoire."""
+    import re
+    cleaned = name.lower()
+    cleaned = re.sub(r"[^a-z0-9]", "-", cleaned)
+    cleaned = re.sub(r"-+", "-", cleaned)
+    return cleaned.strip("-")
+
+
+def migrate(
+    dry_run: bool = typer.Option(False, "--dry-run", help="Affiche le mapping prevu sans deplacer"),
+) -> None:
+    """Migration interactive des features de docs/features/ vers .specify/specs/."""
+    legacy_dir = Path("docs/features")
+
+    if not legacy_dir.is_dir():
+        info("Rien a migrer : docs/features/ n'existe pas.")
+        return
+
+    # Scanner les features legacy
+    features = []
+    for d in sorted(legacy_dir.iterdir()):
+        state_file = d / "state.json"
+        if d.is_dir() and state_file.is_file():
+            state = read_state(state_file)
+            features.append((d, state))
+
+    if not features:
+        info("Rien a migrer : aucune feature avec state.json dans docs/features/.")
+        return
+
+    header(f"devflow migrate — {len(features)} feature(s) a migrer")
+    console.print()
+
+    specs_root = get_specs_root()
+    specs_root.mkdir(parents=True, exist_ok=True)
+
+    migrated = 0
+    skipped = 0
+    conflicts = 0
+
+    for legacy_path, state in features:
+        issue_id = state.issueId
+        step = state.currentStep
+        artifact_count = sum(1 for f in legacy_path.iterdir() if f.is_file())
+
+        console.print(f"  [bold]{issue_id}[/bold] — etape: {step}, {artifact_count} artefacts")
+
+        if dry_run:
+            console.print(f"    [dim](dry-run) Serait migre vers .specify/specs/[/dim]")
+            migrated += 1
+            continue
+
+        # Demander un short-name
+        try:
+            default_name = _clean_short_name(issue_id)
+            short_name = typer.prompt(
+                f"    Short-name pour {issue_id}",
+                default=default_name,
+            )
+        except (KeyboardInterrupt, typer.Abort):
+            console.print(f"    [yellow]Ignore (annule)[/yellow]")
+            skipped += 1
+            continue
+
+        clean_name = _clean_short_name(short_name)
+        num = next_feature_number()
+        target_name = f"{num:03d}-{clean_name}"
+        target_path = specs_root / target_name
+
+        # Verifier les conflits
+        if target_path.exists():
+            warn(f"    Conflit : {target_path} existe deja. Feature ignoree.")
+            conflicts += 1
+            continue
+
+        # Deplacer
+        shutil.move(str(legacy_path), str(target_path))
+        ok(f"    {issue_id} -> .specify/specs/{target_name}/")
+        migrated += 1
+
+    # Recapitulatif
+    console.print()
+    console.rule("Recapitulatif")
+    console.print(f"  Migrees   : {migrated}")
+    if skipped:
+        console.print(f"  Ignorees  : {skipped}")
+    if conflicts:
+        console.print(f"  Conflits  : {conflicts}")
+    if dry_run:
+        console.print()
+        console.print("[dim]Mode dry-run : aucun fichier deplace.[/dim]")

devflow_cli/commands/regen.py

@@ -0,0 +1,93 @@
+"""devflow regen — Detection et regeneration en cascade des artefacts desuets."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from devflow_cli.core.git import current_branch
+from devflow_cli.core.staleness import get_staleness, get_stale_artifacts, REGEN_COMMANDS
+from devflow_cli.utils.console import console, ok, info, header
+from devflow_cli.utils.paths import resolve_feature_dir
+
+
+def regen(
+    only: Optional[str] = typer.Option(None, "--only", help="Regenerer uniquement cet artefact (plan, tasks)"),
+    json_output: bool = typer.Option(False, "--json", help="Sortie JSON pour integration Claude Code"),
+) -> None:
+    """Detecte et propose la regeneration des artefacts desuets."""
+    branch = current_branch()
+    feature_dir = resolve_feature_dir(branch) if branch else None
+    if feature_dir is None:
+        if json_output:
+            print(json.dumps({"error": "Aucune feature trouvee"}))
+        else:
+            console.print("Aucune feature trouvee dans specs/ ou docs/features/.")
+        raise typer.Exit(1)
+
+    constitution_path = Path(".specify/memory/constitution.md")
+    const_path = constitution_path if constitution_path.is_file() else None
+
+    staleness = get_staleness(feature_dir, const_path)
+    stale_list = get_stale_artifacts(feature_dir, const_path)
+
+    # Filtrage --only
+    if only:
+        target = f"{only}.md" if not only.endswith(".md") else only
+        stale_list = [s for s in stale_list if s.artifact == target]
+
+    if json_output:
+        output = {
+            "feature_dir": str(feature_dir),
+            "stale": [
+                {
+                    "artifact": s.artifact,
+                    "reason": s.reason,
+                    "command": REGEN_COMMANDS.get(s.artifact, ""),
+                }
+                for s in stale_list
+            ],
+            "fresh": [
+                name for name, info in staleness.items()
+                if info.state == "fresh"
+            ],
+            "missing": [
+                name for name, info in staleness.items()
+                if info.state == "missing"
+            ],
+        }
+        print(json.dumps(output, indent=2))
+        return
+
+    header(f"devflow regen — {feature_dir.name}")
+    console.print()
+
+    if not stale_list:
+        ok("Tout est synchronise. Aucune regeneration necessaire.")
+        return
+
+    console.print("Artefacts desuets detectes :")
+    for s in stale_list:
+        console.print(f"  [yellow]{s.artifact}[/yellow] — {s.reason}")
+
+    console.print()
+    console.print("Commandes a executer :")
+    for i, s in enumerate(stale_list, 1):
+        cmd = REGEN_COMMANDS.get(s.artifact, "N/A")
+        console.print(f"  {i}. {cmd}")
+
+    console.print()
+    if typer.confirm("Regenerer ?", default=False):
+        console.print()
+        info("Lancez les commandes suivantes dans l'ordre :")
+        for s in stale_list:
+            cmd = REGEN_COMMANDS.get(s.artifact)
+            if cmd:
+                console.print(f"  → {cmd}")
+        console.print()
+        info("Ou utilisez /devflow.regen pour execution automatique.")
+    else:
+        console.print("Annule.")

devflow_cli/commands/status.py

@@ -0,0 +1,118 @@
+"""devflow status — Affiche le statut des features."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from devflow_cli import STEPS, ARTIFACTS
+from devflow_cli.core.state import read_state
+from devflow_cli.core.staleness import get_staleness
+from devflow_cli.utils.console import console, make_table
+from devflow_cli.utils.paths import get_specs_root, resolve_feature_dir
+
+
+def status(
+    issue_id: Optional[str] = typer.Argument(None, help="ID de la feature (optionnel)"),
+) -> None:
+    """Lecture rapide du statut d'une feature ou liste toutes les features."""
+    if issue_id is None:
+        _list_features()
+    else:
+        _show_feature(issue_id)
+
+
+def _list_features() -> None:
+    """Liste toutes les features en scannant trois repertoires."""
+    scan_dirs = [
+        (Path(".specify/specs"), False),
+        (Path("specs"), True),
+        (Path("docs/features"), True),
+    ]
+
+    table = make_table("ID", "Etape", "Completees", "Location", title="Features")
+
+    found = False
+    has_legacy = False
+
+    for scan_root, is_legacy in scan_dirs:
+        if not scan_root.is_dir():
+            continue
+        for d in sorted(scan_root.iterdir()):
+            state_file = d / "state.json"
+            if not state_file.is_file():
+                continue
+            found = True
+            state = read_state(state_file)
+            location = "[yellow][legacy][/yellow]" if is_legacy else ""
+            if is_legacy:
+                has_legacy = True
+            table.add_row(
+                state.issueId,
+                state.currentStep,
+                f"{state.completed_count}/{state.total_steps}",
+                location,
+            )
+
+    if found:
+        console.print(table)
+        if has_legacy:
+            console.print(
+                "\n[yellow]Astuce: utilisez 'devflow migrate' pour deplacer "
+                "les features legacy vers .specify/specs/[/yellow]"
+            )
+    else:
+        console.print("Aucune feature initialisee.")
+
+
+def _show_feature(issue_id: str) -> None:
+    """Affiche le detail d'une feature."""
+    feature_dir = resolve_feature_dir(issue_id)
+
+    if feature_dir is None:
+        console.print(f"Feature {issue_id} non initialisee.")
+        console.print(f"Lancer : devflow feature {issue_id}")
+        raise typer.Exit(1)
+
+    state_file = feature_dir / "state.json"
+
+    if not state_file.is_file():
+        console.print(f"Feature {issue_id} non initialisee.")
+        console.print(f"Lancer : devflow feature {issue_id}")
+        raise typer.Exit(1)
+
+    state = read_state(state_file)
+
+    console.rule(f"[bold]devflow — {issue_id}[/bold]")
+    console.print()
+    console.print(f"Etape courante : [bold]{state.currentStep}[/bold]")
+    console.print(f"Cree le        : {state.createdAt}")
+    console.print(f"Mis a jour     : {state.updatedAt}")
+    console.print()
+
+    # Staleness detection
+    constitution_path = Path(".specify/memory/constitution.md")
+    staleness = get_staleness(feature_dir, constitution_path if constitution_path.is_file() else None)
+
+    console.print("Artefacts :")
+    for artifact in ARTIFACTS:
+        path = feature_dir / artifact
+        stale_info = staleness.get(artifact)
+
+        if artifact.endswith("/"):
+            # Directory artifact (e.g. contracts/)
+            if path.is_dir() and any(path.iterdir()):
+                console.print(f"  [green][OK][/green]    {artifact}")
+            elif (feature_dir / artifact.rstrip("/")).with_suffix(".md").is_file():
+                console.print(f"  [green][OK][/green]    {artifact.rstrip('/')}.md")
+            else:
+                console.print(f"  [dim][  ][/dim]    {artifact}")
+        elif path.is_file():
+            if stale_info and stale_info.state == "stale":
+                console.print(f"  [yellow][STALE][/yellow] {artifact} — {stale_info.reason}")
+            else:
+                console.print(f"  [green][OK][/green]    {artifact}")
+        else:
+            console.print(f"  [dim][  ][/dim]    {artifact}")