devflow-cli 1.0.0__py3-none-any.whl

devflow_cli/core/manifest.py

@@ -0,0 +1,167 @@
+"""Gestion du manifeste de templates devflow (checksums + comparaison)."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from devflow_cli import VERSION
+
+
+@dataclass
+class TemplateStatus:
+    """Resultat de comparaison pour un template."""
+    path: str  # Chemin relatif (ex: "templates/spec-template.md")
+    status: str  # "current" | "outdated" | "modified" | "new" | "unknown"
+    source_hash: str | None = None
+    installed_hash: str | None = None
+    manifest_hash: str | None = None
+
+
+def compute_file_hash(file_path: Path) -> str:
+    """Calcule le SHA-256 d'un fichier et retourne le digest hex."""
+    h = hashlib.sha256()
+    h.update(file_path.read_bytes())
+    return f"sha256:{h.hexdigest()}"
+
+
+def compute_source_manifest(devflow_root: Path) -> dict:
+    """Calcule le manifeste des templates source dans le repo devflow.
+
+    Parcourt les memes categories que install_devflow() :
+    templates/, templates/export/, templates/checklists/,
+    templates/contracts/, scripts/*.sh, scripts/*.ps1
+    """
+    templates: dict[str, str] = {}
+
+    # Templates racine
+    tpl_dir = devflow_root / "templates"
+    if tpl_dir.is_dir():
+        for f in sorted(tpl_dir.glob("*")):
+            if f.is_file():
+                rel = f"templates/{f.name}"
+                templates[rel] = compute_file_hash(f)
+
+        # Sous-repertoires
+        for sub in ("export", "checklists", "contracts"):
+            sub_dir = tpl_dir / sub
+            if sub_dir.is_dir():
+                for f in sorted(sub_dir.glob("*")):
+                    if f.is_file():
+                        rel = f"templates/{sub}/{f.name}"
+                        templates[rel] = compute_file_hash(f)
+
+    # Scripts
+    scripts_dir = devflow_root / "scripts"
+    if scripts_dir.is_dir():
+        for ext in ("*.sh", "*.ps1"):
+            for f in sorted(scripts_dir.glob(ext)):
+                if f.is_file():
+                    rel = f"scripts/{f.name}"
+                    templates[rel] = compute_file_hash(f)
+
+    return {
+        "devflow_version": VERSION,
+        "computed_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "templates": templates,
+    }
+
+
+def load_manifest(claude_dir: Path) -> dict | None:
+    """Charge le manifeste d'installation depuis claude_dir/.devflow-manifest.json.
+
+    Returns:
+        Le manifeste en dict, ou None si absent ou corrompu.
+    """
+    manifest_file = claude_dir / ".devflow-manifest.json"
+    if not manifest_file.is_file():
+        return None
+    try:
+        return json.loads(manifest_file.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        from devflow_cli.utils.console import warn
+        warn(f"Manifeste corrompu ou illisible : {manifest_file} ({type(e).__name__}: {e})")
+        return None
+
+
+def save_manifest(claude_dir: Path, manifest_data: dict) -> None:
+    """Sauvegarde le manifeste d'installation dans claude_dir/.devflow-manifest.json."""
+    manifest_file = claude_dir / ".devflow-manifest.json"
+    manifest_file.write_text(
+        json.dumps(manifest_data, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def compare_manifests(
+    source_manifest: dict,
+    installed_manifest: dict | None,
+    claude_dir: Path,
+) -> list[TemplateStatus]:
+    """Compare le manifeste source avec l'installation courante.
+
+    Args:
+        source_manifest: Manifeste calcule depuis le repo devflow.
+        installed_manifest: Manifeste d'installation (ou None si legacy).
+        claude_dir: Repertoire ~/.claude/.
+
+    Returns:
+        Liste de TemplateStatus pour chaque template source.
+    """
+    results: list[TemplateStatus] = []
+    manifest_templates = (installed_manifest or {}).get("templates", {})
+
+    for rel_path, source_hash in sorted(source_manifest.get("templates", {}).items()):
+        installed_file = claude_dir / rel_path
+        manifest_hash = manifest_templates.get(rel_path)
+
+        if not installed_file.is_file():
+            results.append(TemplateStatus(
+                path=rel_path,
+                status="new",
+                source_hash=source_hash,
+            ))
+            continue
+
+        installed_hash = compute_file_hash(installed_file)
+
+        if source_hash == installed_hash:
+            results.append(TemplateStatus(
+                path=rel_path,
+                status="current",
+                source_hash=source_hash,
+                installed_hash=installed_hash,
+                manifest_hash=manifest_hash,
+            ))
+        elif installed_manifest is not None and manifest_hash is not None:
+            if manifest_hash == installed_hash:
+                # Fichier non modifie localement, mais source a change
+                results.append(TemplateStatus(
+                    path=rel_path,
+                    status="outdated",
+                    source_hash=source_hash,
+                    installed_hash=installed_hash,
+                    manifest_hash=manifest_hash,
+                ))
+            else:
+                # Fichier modifie localement ET source a change
+                results.append(TemplateStatus(
+                    path=rel_path,
+                    status="modified",
+                    source_hash=source_hash,
+                    installed_hash=installed_hash,
+                    manifest_hash=manifest_hash,
+                ))
+        else:
+            # Pas de manifeste → impossible de distinguer
+            results.append(TemplateStatus(
+                path=rel_path,
+                status="unknown",
+                source_hash=source_hash,
+                installed_hash=installed_hash,
+            ))
+
+    return results

devflow_cli/core/scanner.py

@@ -0,0 +1,136 @@
+"""Detection stack, arborescence, conventions pour generation de contexte."""
+
+from __future__ import annotations
+
+import os
+from collections import Counter
+from pathlib import Path
+
+EXCLUDED_DIRS = {
+    "node_modules", ".git", "build", "dist", "__pycache__",
+    ".dart_tool", ".gradle", ".DS_Store", ".idea", ".vscode",
+}
+
+STACK_MARKERS: list[tuple[str, str]] = [
+    ("package.json", "Node.js"),
+    ("angular.json", "Angular"),
+    ("pom.xml", "Java/Maven"),
+    ("build.gradle", "Java/Gradle"),
+    ("pubspec.yaml", "Flutter/Dart"),
+    ("pyproject.toml", "Python"),
+    ("requirements.txt", "Python"),
+    ("go.mod", "Go"),
+    ("Cargo.toml", "Rust"),
+    ("tsconfig.json", "TypeScript"),
+]
+
+
+def detect_stack(project_dir: Path) -> str:
+    """Detecte la stack technique du projet."""
+    stacks: list[str] = []
+    for marker, stack in STACK_MARKERS:
+        if (project_dir / marker).is_file():
+            if stack not in stacks:
+                stacks.append(stack)
+    return ", ".join(stacks) if stacks else "Non detectee"
+
+
+def _should_exclude(path: Path) -> bool:
+    return any(part in EXCLUDED_DIRS for part in path.parts)
+
+
+def build_tree(project_dir: Path, max_depth: int = 2, max_lines: int = 60) -> str:
+    """Genere l'arborescence du projet (2 niveaux)."""
+    lines: list[str] = []
+    base = project_dir.resolve()
+
+    for root_str, dirs, files in os.walk(base):
+        root_path = Path(root_str)
+        rel = root_path.relative_to(base)
+        depth = len(rel.parts)
+
+        if depth > max_depth:
+            dirs.clear()
+            continue
+
+        # Filtrer les repertoires exclus
+        dirs[:] = sorted(d for d in dirs if d not in EXCLUDED_DIRS)
+
+        rel_str = str(rel) if str(rel) != "." else ""
+        if rel_str:
+            lines.append(rel_str + "/")
+
+        if depth < max_depth:
+            for f in sorted(files):
+                if f == ".DS_Store":
+                    continue
+                file_rel = str(rel / f) if rel_str else f
+                lines.append(file_rel)
+
+        if len(lines) >= max_lines:
+            break
+
+    return "\n".join(lines[:max_lines])
+
+
+def detect_extensions(project_dir: Path) -> str:
+    """Top 5 extensions de fichiers par nombre."""
+    counter: Counter[str] = Counter()
+
+    for root_str, dirs, files in os.walk(project_dir):
+        root_path = Path(root_str)
+        if _should_exclude(root_path.relative_to(project_dir)):
+            dirs.clear()
+            continue
+        dirs[:] = [d for d in dirs if d not in EXCLUDED_DIRS]
+        for f in files:
+            ext = Path(f).suffix
+            if ext:
+                counter[ext] += 1
+
+    lines = []
+    for ext, count in counter.most_common(5):
+        lines.append(f"- {ext} ({count} fichiers)")
+    return "\n".join(lines) if lines else "Aucune extension detectee"
+
+
+def detect_conventions(project_dir: Path) -> str:
+    """Detecte les conventions de code configurees."""
+    conventions: list[str] = []
+
+    if (project_dir / ".editorconfig").is_file():
+        conventions.append(".editorconfig")
+
+    for name in (".prettierrc", ".prettierrc.json", ".prettierrc.js"):
+        if (project_dir / name).is_file():
+            conventions.append("Prettier")
+            break
+
+    for name in (".eslintrc", ".eslintrc.json", ".eslintrc.js", "eslint.config.js"):
+        if (project_dir / name).is_file():
+            conventions.append("ESLint")
+            break
+
+    for name in (".stylelintrc", ".stylelintrc.json"):
+        if (project_dir / name).is_file():
+            conventions.append("Stylelint")
+            break
+
+    if (project_dir / "CLAUDE.md").is_file():
+        conventions.append("CLAUDE.md")
+
+    if (project_dir / ".cursor" / "rules").exists():
+        conventions.append("Cursor Rules")
+
+    if not conventions:
+        return "Aucune convention specifique detectee"
+    return "\n".join(f"- {c}" for c in conventions)
+
+
+def read_constitution(project_dir: Path, max_lines: int = 20) -> str:
+    """Lit les premieres lignes de la constitution."""
+    for path in (project_dir / "docs" / "constitution.md", project_dir / "constitution.md"):
+        if path.is_file():
+            lines = path.read_text(encoding="utf-8").splitlines()[:max_lines]
+            return "\n".join(lines)
+    return "Aucune constitution devflow trouvee"

devflow_cli/core/staleness.py

@@ -0,0 +1,135 @@
+"""Detection de la desynchronisation entre artefacts du pipeline."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+# Graphe de dependances lineaire : (upstream, downstream)
+ARTIFACT_DEPS: list[tuple[str, str]] = [
+    ("constitution", "spec.md"),
+    ("spec.md", "plan.md"),
+    ("plan.md", "tasks.md"),
+]
+
+# Mapping artefact → commande speckit de regeneration
+REGEN_COMMANDS: dict[str, str] = {
+    "plan.md": "/speckit.plan",
+    "tasks.md": "/speckit.tasks",
+}
+
+
+@dataclass
+class StalenessInfo:
+    artifact: str
+    state: str  # "fresh", "stale", "missing"
+    reason: str
+    upstream: str
+    mtime: float | None
+
+
+def _get_mtime(path: Path) -> float | None:
+    """Retourne le mtime d'un fichier ou None si absent."""
+    if path.is_file():
+        return path.stat().st_mtime
+    return None
+
+
+def get_staleness(
+    feature_dir: Path,
+    constitution_path: Path | None = None,
+) -> dict[str, StalenessInfo]:
+    """Calcule l'etat de synchronisation de chaque artefact downstream.
+
+    Args:
+        feature_dir: Repertoire contenant les artefacts (specs/<branch>/ ou docs/features/<id>/).
+        constitution_path: Chemin absolu vers la constitution (.specify/memory/constitution.md).
+
+    Returns:
+        Dict {artifact_name: StalenessInfo} pour chaque downstream dans ARTIFACT_DEPS.
+    """
+    result: dict[str, StalenessInfo] = {}
+    stale_names: set[str] = set()
+
+    for upstream_name, downstream_name in ARTIFACT_DEPS:
+        # Si l'upstream est deja stale, le downstream est stale par propagation
+        if upstream_name in stale_names:
+            downstream_path = feature_dir / downstream_name
+            downstream_mtime = _get_mtime(downstream_path)
+            if downstream_mtime is not None:
+                result[downstream_name] = StalenessInfo(
+                    artifact=downstream_name,
+                    state="stale",
+                    reason=f"{upstream_name} est desuet (cascade)",
+                    upstream=upstream_name,
+                    mtime=downstream_mtime,
+                )
+                stale_names.add(downstream_name)
+            else:
+                result[downstream_name] = StalenessInfo(
+                    artifact=downstream_name,
+                    state="missing",
+                    reason=f"{downstream_name} absent",
+                    upstream=upstream_name,
+                    mtime=None,
+                )
+            continue
+
+        # Resoudre le chemin upstream
+        if upstream_name == "constitution":
+            if constitution_path is None or not constitution_path.is_file():
+                continue
+            upstream_mtime = constitution_path.stat().st_mtime
+        else:
+            upstream_path = feature_dir / upstream_name
+            upstream_mtime = _get_mtime(upstream_path)
+            if upstream_mtime is None:
+                continue  # Upstream absent → pas de comparaison possible
+
+        # Resoudre le chemin downstream
+        downstream_path = feature_dir / downstream_name
+        downstream_mtime = _get_mtime(downstream_path)
+
+        if downstream_mtime is None:
+            result[downstream_name] = StalenessInfo(
+                artifact=downstream_name,
+                state="missing",
+                reason=f"{downstream_name} absent",
+                upstream=upstream_name,
+                mtime=None,
+            )
+        elif upstream_mtime > downstream_mtime:
+            result[downstream_name] = StalenessInfo(
+                artifact=downstream_name,
+                state="stale",
+                reason=f"{upstream_name} modifie apres {downstream_name}",
+                upstream=upstream_name,
+                mtime=downstream_mtime,
+            )
+            stale_names.add(downstream_name)
+        else:
+            if downstream_name not in result:
+                result[downstream_name] = StalenessInfo(
+                    artifact=downstream_name,
+                    state="fresh",
+                    reason="",
+                    upstream=upstream_name,
+                    mtime=downstream_mtime,
+                )
+
+    return result
+
+
+def get_stale_artifacts(
+    feature_dir: Path,
+    constitution_path: Path | None = None,
+) -> list[StalenessInfo]:
+    """Retourne uniquement les artefacts stale, ordonnes par pipeline."""
+    staleness = get_staleness(feature_dir, constitution_path)
+    # Ordre du pipeline
+    pipeline_order = [ds for _, ds in ARTIFACT_DEPS]
+    return [
+        info for name in pipeline_order
+        if (info := staleness.get(name)) and info.state == "stale"
+    ]

devflow_cli/core/state.py

@@ -0,0 +1,69 @@
+"""Lecture/ecriture de state.json pour les features devflow."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+from devflow_cli import STEPS
+
+
+@dataclass
+class FeatureState:
+    issueId: str
+    currentStep: str = "spec"
+    completedSteps: list[str] = field(default_factory=list)
+    stepTimestamps: dict[str, dict[str, str]] = field(default_factory=dict)
+    reviewIterations: dict[str, int] = field(default_factory=dict)
+    createdAt: str = ""
+    updatedAt: str = ""
+
+    def __post_init__(self) -> None:
+        now = _now_iso()
+        if not self.createdAt:
+            self.createdAt = now
+        if not self.updatedAt:
+            self.updatedAt = now
+
+    @property
+    def completed_count(self) -> int:
+        return len(self.completedSteps)
+
+    @property
+    def total_steps(self) -> int:
+        return len(STEPS)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def read_state(state_file: Path) -> FeatureState:
+    """Lit un state.json et retourne un FeatureState."""
+    data = json.loads(state_file.read_text(encoding="utf-8"))
+    return FeatureState(**{
+        k: v for k, v in data.items()
+        if k in FeatureState.__dataclass_fields__
+    })
+
+
+def write_state(state_file: Path, state: FeatureState) -> None:
+    """Ecrit un FeatureState dans state.json."""
+    state.updatedAt = _now_iso()
+    state_file.write_text(
+        json.dumps(state.to_dict(), indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def create_state(state_file: Path, issue_id: str) -> FeatureState:
+    """Cree un nouveau state.json pour une feature."""
+    state = FeatureState(issueId=issue_id)
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+    write_state(state_file, state)
+    return state

devflow_cli/utils/console.py

@@ -0,0 +1,34 @@
+"""Rich console helpers."""
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def ok(msg: str) -> None:
+    console.print(f"[green][OK][/green]   {msg}")
+
+
+def warn(msg: str) -> None:
+    console.print(f"[yellow][WARN][/yellow] {msg}")
+
+
+def fail(msg: str) -> None:
+    console.print(f"[red][FAIL][/red] {msg}")
+
+
+def info(msg: str) -> None:
+    console.print(f"[blue][INFO][/blue] {msg}")
+
+
+def header(title: str) -> None:
+    console.rule(f"[bold]{title}[/bold]")
+
+
+def make_table(*columns: str, title: str | None = None) -> Table:
+    """Cree une table Rich avec les colonnes specifiees."""
+    table = Table(title=title, show_header=True, header_style="bold")
+    for col in columns:
+        table.add_column(col)
+    return table

devflow_cli/utils/paths.py

@@ -0,0 +1,141 @@
+"""Resolution de chemins devflow."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from pathlib import Path
+
+
+def get_devflow_root() -> Path:
+    """Racine du projet devflow (templates, commands, agents, extensions)."""
+    if root := os.environ.get("DEVFLOW_ROOT"):
+        return Path(root)
+    # En dev: src/devflow_cli/utils/paths.py -> remonter 4 niveaux
+    return Path(__file__).resolve().parent.parent.parent.parent
+
+
+def get_claude_dir() -> Path:
+    """Repertoire ~/.claude/ (ou CLAUDE_DIR si defini)."""
+    return Path(os.environ.get("CLAUDE_DIR", Path.home() / ".claude"))
+
+
+def get_feature_dir(issue_id: str, project_dir: Path | None = None) -> Path:
+    """Deprecated: utiliser resolve_feature_dir() a la place.
+
+    Repertoire d'une feature: docs/features/<issue_id>/.
+    Conserve pour retrocompatibilite uniquement.
+    """
+    base = project_dir or Path.cwd()
+    return base / "docs" / "features" / issue_id
+
+
+def get_specs_root(project_dir: Path | None = None) -> Path:
+    """Repertoire central des artefacts de feature: .specify/specs/."""
+    base = project_dir or Path.cwd()
+    return base / ".specify" / "specs"
+
+
+def resolve_feature_dir(
+    identifier: str,
+    project_dir: Path | None = None,
+) -> Path | None:
+    """Resout le repertoire d'une feature avec fallback triple.
+
+    Ordre de resolution:
+      1. .specify/specs/<identifier ou match>/
+      2. specs/<identifier ou match>/
+      3. docs/features/<identifier>/
+
+    Args:
+        identifier: Nom de branche, issue ID, ou pattern a chercher.
+        project_dir: Racine du projet (defaut: cwd).
+
+    Returns:
+        Path vers le repertoire de la feature, ou None si introuvable.
+    """
+    base = project_dir or Path.cwd()
+
+    search_roots = [
+        base / ".specify" / "specs",
+        base / "specs",
+        base / "docs" / "features",
+    ]
+
+    for root in search_roots:
+        if not root.is_dir():
+            continue
+        # Match exact
+        exact = root / identifier
+        if exact.is_dir():
+            return exact
+        # Match partiel (ex: identifier "KS-123" dans "005-ks-123")
+        for d in root.iterdir():
+            if d.is_dir() and identifier.lower() in d.name.lower():
+                return d
+
+    return None
+
+
+def next_feature_number(project_dir: Path | None = None) -> int:
+    """Determine le prochain numero de feature disponible.
+
+    Scanne .specify/specs/, specs/ et les branches git pour trouver
+    le plus grand numero existant, puis retourne le suivant.
+    Utilise un verrou fichier (fcntl.flock) pour eviter les race conditions.
+    """
+    base = project_dir or Path.cwd()
+
+    def _scan() -> int:
+        highest = 0
+
+        # Scanner les repertoires de specs
+        for specs_dir in [base / ".specify" / "specs", base / "specs"]:
+            if not specs_dir.is_dir():
+                continue
+            for d in specs_dir.iterdir():
+                if not d.is_dir():
+                    continue
+                m = re.match(r"^(\d+)", d.name)
+                if m:
+                    num = int(m.group(1))
+                    if num > highest:
+                        highest = num
+
+        # Scanner les branches git
+        try:
+            result = subprocess.run(
+                ["git", "branch", "-a"],
+                capture_output=True,
+                text=True,
+                cwd=str(base),
+                timeout=5,
+            )
+            if result.returncode == 0:
+                for line in result.stdout.splitlines():
+                    clean = line.strip().lstrip("* ").split("/")[-1]
+                    m = re.match(r"^(\d{3})-", clean)
+                    if m:
+                        num = int(m.group(1))
+                        if num > highest:
+                            highest = num
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        return highest + 1
+
+    # Verrouillage fichier (POSIX) pour eviter les race conditions
+    try:
+        import fcntl
+
+        lock_dir = base / ".specify" / "specs"
+        lock_dir.mkdir(parents=True, exist_ok=True)
+        lock_file = lock_dir / ".feature-lock"
+
+        with open(lock_file, "a+") as f:
+            fcntl.flock(f, fcntl.LOCK_EX)
+            return _scan()
+    except ImportError:
+        # Windows : pas de fcntl, on execute sans lock
+        return _scan()