devflow-cli 1.0.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -0,0 +1,51 @@
+"""devflow CLI — Spec-Driven Development workflow."""
+
+VERSION = "1.0.0"
+
+STEPS = [
+    "constitution",
+    "spec",
+    "clarify",
+    "review-spec",
+    "research",
+    "plan",
+    "contracts",
+    "tasks",
+    "review-tasks",
+    "implement",
+    "review-impl",
+    "docs",
+    "done",
+]
+
+STEP_LINEAR_MAPPING = {
+    "spec": "Spec",
+    "clarify": "Spec",
+    "review-spec": "Review",
+    "research": "Research",
+    "plan": "Plan",
+    "contracts": "Plan",
+    "tasks": "Tasks",
+    "review-tasks": "Review",
+    "implement": "In Progress",
+    "review-impl": "Doc",
+    "docs": "Doc",
+    "done": "Done",
+}
+
+SUPPORTED_AGENTS = ["claude-code"]
+
+ARTIFACTS = [
+    "spec.md",
+    "clarify-log.md",
+    "research.md",
+    "plan.md",
+    "contracts/",
+    "data-model.md",
+    "quickstart.md",
+    "tasks.md",
+    "docs.md",
+    "review-log.md",
+    "analysis.md",
+    "checklist.md",
+]

devflow_cli/cli.py

@@ -0,0 +1,52 @@
+"""devflow CLI — Point d'entree principal."""
+
+from __future__ import annotations
+
+import typer
+
+from devflow_cli import VERSION
+from devflow_cli.commands.init_cmd import init
+from devflow_cli.commands.check import check
+from devflow_cli.commands.status import status
+from devflow_cli.commands.feature import feature
+from devflow_cli.commands.context import context
+from devflow_cli.commands.export_cmd import export
+from devflow_cli.commands.regen import regen
+from devflow_cli.commands.migrate_cmd import migrate
+from devflow_cli.commands.upgrade_cmd import upgrade
+from devflow_cli.commands import extension
+
+app = typer.Typer(
+    name="devflow",
+    help="Spec-Driven Development workflow CLI",
+    no_args_is_help=True,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"devflow CLI v{VERSION}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", callback=version_callback, is_eager=True, help="Affiche la version"),
+) -> None:
+    """devflow — Spec-Driven Development workflow CLI."""
+
+
+app.command()(init)
+app.command()(check)
+app.command()(status)
+app.command()(feature)
+app.command()(context)
+app.command(name="export")(export)
+app.command()(regen)
+app.command()(migrate)
+app.command()(upgrade)
+app.add_typer(extension.app, name="extension")
+
+
+if __name__ == "__main__":
+    app()

devflow_cli/commands/check.py

@@ -0,0 +1,167 @@
+"""devflow check — Verifie les prerequis devflow."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from devflow_cli.utils.console import console, ok, warn, fail
+from devflow_cli.utils.paths import get_claude_dir
+
+
+def _cmd_exists(name: str) -> str | None:
+    """Retourne le chemin de la commande si elle existe."""
+    return shutil.which(name)
+
+
+def _count_files(directory: Path, pattern: str) -> int:
+    return len(list(directory.glob(pattern)))
+
+
+def check() -> None:
+    """Verifie les prerequis (outils, fichiers, config)."""
+    ok_count = 0
+    warn_count = 0
+    fail_count = 0
+
+    claude_dir = get_claude_dir()
+
+    console.print("Verification des prerequis devflow...")
+    console.print()
+
+    # --- Outils ---
+
+    # git
+    git_path = _cmd_exists("git")
+    if git_path:
+        result = subprocess.run(["git", "--version"], capture_output=True, text=True)
+        version = result.stdout.strip().replace("git version ", "")
+        ok(f"git -- {git_path} (version {version})")
+        ok_count += 1
+    else:
+        fail("git -- non installe")
+        fail_count += 1
+
+    # claude CLI
+    claude_path = _cmd_exists("claude")
+    if claude_path:
+        ok(f"claude CLI -- {claude_path}")
+        ok_count += 1
+    else:
+        fail("claude CLI -- non installee")
+        fail_count += 1
+
+    # --- Structure ~/.claude/ ---
+
+    if claude_dir.is_dir():
+        ok("~/.claude/ -- present")
+        ok_count += 1
+    else:
+        fail("~/.claude/ -- absent")
+        fail_count += 1
+
+    for subdir in ("commands", "agents", "templates"):
+        d = claude_dir / subdir
+        if d.is_dir():
+            ok(f"~/.claude/{subdir}/ -- present")
+            ok_count += 1
+        else:
+            fail(f"~/.claude/{subdir}/ -- absent")
+            fail_count += 1
+
+    # --- Installation devflow ---
+
+    # Commandes devflow
+    cmd_dir = claude_dir / "commands"
+    if cmd_dir.is_dir():
+        count = _count_files(cmd_dir, "devflow*.md")
+        if count > 0:
+            ok(f"commandes devflow -- {count} installees")
+            ok_count += 1
+        else:
+            fail("commandes devflow -- non installees")
+            fail_count += 1
+    else:
+        fail("commandes devflow -- non installees")
+        fail_count += 1
+
+    # Agents devflow
+    agents_dir = claude_dir / "agents"
+    if agents_dir.is_dir():
+        count = _count_files(agents_dir, "devflow*.md")
+        if count > 0:
+            ok(f"agents devflow -- {count} installes")
+            ok_count += 1
+        else:
+            fail("agents devflow -- non installes")
+            fail_count += 1
+    else:
+        fail("agents devflow -- non installes")
+        fail_count += 1
+
+    # Templates
+    tpl_dir = claude_dir / "templates"
+    if tpl_dir.is_dir() and any(tpl_dir.iterdir()):
+        count = _count_files(tpl_dir, "*-template.md")
+        ok(f"templates -- {count} disponibles")
+        ok_count += 1
+    else:
+        warn("templates -- ~/.claude/templates/ vide ou absent")
+        warn_count += 1
+
+    # Scripts executables
+    scripts_ok = True
+    scripts_dir = claude_dir / "scripts"
+    for script_name in ("setup-feature.sh", "devflow-cli.sh", "check-prerequisites.sh"):
+        script = scripts_dir / script_name
+        if script.is_file() and not (script.stat().st_mode & 0o111):
+            scripts_ok = False
+    if scripts_ok:
+        ok("scripts -- permissions +x OK")
+        ok_count += 1
+    else:
+        warn("scripts -- certains scripts sans permission +x")
+        warn_count += 1
+
+    # --- Projet courant ---
+
+    if Path("docs").is_dir():
+        ok("docs/ -- present dans le projet courant")
+        ok_count += 1
+    else:
+        warn("docs/ -- absent du projet courant")
+        warn_count += 1
+
+    # --- Optionnel ---
+
+    linear_configured = False
+    plugins_file = claude_dir / "plugins.json"
+    claude_json = Path.home() / ".claude.json"
+    for cfg_file in (plugins_file, claude_json):
+        if cfg_file.is_file():
+            try:
+                content = cfg_file.read_text()
+                if "linear" in content.lower():
+                    linear_configured = True
+                    break
+            except OSError:
+                pass
+    if linear_configured:
+        ok("Linear MCP -- configure")
+        ok_count += 1
+    else:
+        warn("Linear MCP -- non configure (optionnel)")
+        warn_count += 1
+
+    # --- Resume ---
+
+    console.print()
+    total = ok_count + warn_count + fail_count
+    console.print(f"Resume : {ok_count} OK, {warn_count} WARN, {fail_count} FAIL ({total} checks)")
+
+    if fail_count > 0:
+        raise typer.Exit(1)

devflow_cli/commands/context.py

@@ -0,0 +1,173 @@
+"""devflow context — Genere le contexte projet pour agents IA."""
+
+from __future__ import annotations
+
+import re
+from datetime import date
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from devflow_cli.core.scanner import (
+    detect_stack,
+    build_tree,
+    detect_extensions,
+    detect_conventions,
+    read_constitution,
+)
+from devflow_cli.utils.console import console, ok
+from devflow_cli.utils.paths import get_devflow_root
+
+FORMATS = ("claude", "cursor", "copilot", "windsurf", "all")
+MANUAL_START = "<!-- DEVFLOW:MANUAL_START -->"
+MANUAL_END = "<!-- DEVFLOW:MANUAL_END -->"
+CONTEXT_START = "<!-- DEVFLOW:CONTEXT_START -->"
+CONTEXT_END = "<!-- DEVFLOW:CONTEXT_END -->"
+
+
+def context(
+    format: str = typer.Argument("claude", help="Format de sortie: claude|cursor|copilot|windsurf|all"),
+    project_dir: Optional[Path] = typer.Argument(None, help="Repertoire du projet"),
+) -> None:
+    """Genere le contexte projet pour agents IA."""
+    if format not in FORMATS:
+        console.print(f"[red]Format inconnu : {format}[/red]")
+        console.print(f"Formats valides : {', '.join(FORMATS)}")
+        raise typer.Exit(1)
+
+    proj = (project_dir or Path(".")).resolve()
+    project_name = proj.name
+    today = date.today().isoformat()
+
+    content = _generate_content(proj, project_name, today)
+
+    if format == "all":
+        for fmt in ("claude", "cursor", "copilot", "windsurf"):
+            _write_format(fmt, proj, content)
+    else:
+        _write_format(format, proj, content)
+
+
+def _generate_content(proj: Path, project_name: str, today: str) -> str:
+    """Genere le contenu du contexte."""
+    template_path = get_devflow_root() / "templates" / "agent-context-template.md"
+
+    stack = detect_stack(proj)
+    tree = build_tree(proj)
+    extensions = detect_extensions(proj)
+    conventions = detect_conventions(proj)
+    constitution = read_constitution(proj)
+
+    if template_path.is_file():
+        content = template_path.read_text(encoding="utf-8")
+        content = content.replace("{{PROJECT_NAME}}", project_name)
+        content = content.replace("{{DATE}}", today)
+        content = content.replace("{{STACK}}", stack)
+        content = content.replace("{{TREE}}", tree)
+        content = content.replace("{{EXTENSIONS}}", extensions)
+        content = content.replace("{{CONVENTIONS}}", conventions)
+        content = content.replace("{{CONSTITUTION}}", constitution)
+        return content
+
+    # Fallback sans template
+    return (
+        f"# Contexte projet — {project_name}\n\n"
+        f"> Genere par devflow le {today}\n\n"
+        f"## Stack technique\n\n{stack}\n\n"
+        f"## Arborescence (2 niveaux)\n\n```\n{tree}\n```\n\n"
+        f"## Extensions de fichiers (top 5)\n\n{extensions}\n\n"
+        f"## Conventions detectees\n\n{conventions}\n\n"
+        f"## Constitution devflow\n\n{constitution}\n\n"
+        f"{MANUAL_START}\n{MANUAL_END}\n"
+    )
+
+
+def _extract_manual_block(file_path: Path) -> str | None:
+    """Extrait le bloc manuel existant d'un fichier."""
+    if not file_path.is_file():
+        return None
+    text = file_path.read_text(encoding="utf-8")
+    match = re.search(
+        rf"{re.escape(MANUAL_START)}.*?{re.escape(MANUAL_END)}",
+        text,
+        re.DOTALL,
+    )
+    return match.group(0) if match else None
+
+
+def _inject_manual_block(content: str, manual_block: str | None) -> str:
+    """Reinjecte le bloc manuel dans le contenu genere."""
+    if not manual_block:
+        return content
+    return re.sub(
+        rf"{re.escape(MANUAL_START)}.*?{re.escape(MANUAL_END)}",
+        manual_block,
+        content,
+        flags=re.DOTALL,
+    )
+
+
+def _write_format(fmt: str, proj: Path, content: str) -> None:
+    """Ecrit le contexte dans le format cible."""
+    if fmt == "claude":
+        _write_claude(proj, content)
+    elif fmt == "cursor":
+        _write_cursor(proj, content)
+    elif fmt == "copilot":
+        _write_copilot(proj, content)
+    elif fmt == "windsurf":
+        _write_windsurf(proj, content)
+
+
+def _write_claude(proj: Path, content: str) -> None:
+    target = proj / "CLAUDE.md"
+    manual = _extract_manual_block(target)
+    content = _inject_manual_block(content, manual)
+
+    if target.is_file():
+        text = target.read_text(encoding="utf-8")
+        if CONTEXT_START in text:
+            # Remplacer la section existante
+            before = text[:text.index(CONTEXT_START)]
+            after = text[text.index(CONTEXT_END) + len(CONTEXT_END):]
+            text = f"{before}{CONTEXT_START}\n\n{content}\n\n{CONTEXT_END}{after}"
+        else:
+            text += f"\n{CONTEXT_START}\n\n{content}\n\n{CONTEXT_END}\n"
+        target.write_text(text, encoding="utf-8")
+    else:
+        target.write_text(f"{CONTEXT_START}\n\n{content}\n\n{CONTEXT_END}\n", encoding="utf-8")
+
+    ok(f"Contexte ecrit dans {target}")
+
+
+def _write_cursor(proj: Path, content: str) -> None:
+    rules_dir = proj / ".cursor" / "rules"
+    rules_dir.mkdir(parents=True, exist_ok=True)
+    target = rules_dir / "project-context.mdc"
+    manual = _extract_manual_block(target)
+    content = _inject_manual_block(content, manual)
+
+    frontmatter = '---\ndescription: Contexte projet genere par devflow\nglobs: ["**/*"]\n---\n\n'
+    target.write_text(frontmatter + content, encoding="utf-8")
+    ok(f"Contexte ecrit dans {target}")
+
+
+def _write_copilot(proj: Path, content: str) -> None:
+    github_dir = proj / ".github"
+    github_dir.mkdir(parents=True, exist_ok=True)
+    target = github_dir / "copilot-instructions.md"
+    manual = _extract_manual_block(target)
+    content = _inject_manual_block(content, manual)
+
+    target.write_text(content, encoding="utf-8")
+    ok(f"Contexte ecrit dans {target}")
+
+
+def _write_windsurf(proj: Path, content: str) -> None:
+    target = proj / ".windsurfrules"
+    manual = _extract_manual_block(target)
+    content = _inject_manual_block(content, manual)
+
+    target.write_text(content, encoding="utf-8")
+    ok(f"Contexte ecrit dans {target}")

devflow_cli/commands/export_cmd.py

@@ -0,0 +1,149 @@
+"""devflow export — Exporte devflow pour d'autres agents IA."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from devflow_cli.utils.console import console, ok
+from devflow_cli.utils.paths import get_devflow_root
+
+FORMATS = ("cursor", "copilot", "windsurf")
+
+
+def export(
+    format: str = typer.Argument(..., help="Format: cursor|copilot|windsurf"),
+    output_dir: Optional[Path] = typer.Argument(None, help="Dossier de sortie"),
+) -> None:
+    """Exporte les commandes/agents devflow vers Cursor/Copilot/Windsurf."""
+    if format not in FORMATS:
+        console.print(f"[red]Format inconnu : {format}[/red]")
+        console.print(f"Formats valides : {', '.join(FORMATS)}")
+        raise typer.Exit(1)
+
+    out = (output_dir or Path(".")).resolve()
+    content = _build_content()
+
+    if format == "cursor":
+        _export_cursor(out, content)
+    elif format == "copilot":
+        _export_copilot(out, content)
+    elif format == "windsurf":
+        _export_windsurf(out, content)
+
+
+def _build_content() -> str:
+    """Genere le contenu a partir des commandes et agents."""
+    root = get_devflow_root()
+    lines: list[str] = []
+
+    lines.append("# devflow — Workflow de developpement spec-driven")
+    lines.append("")
+    lines.append("## Flux")
+    lines.append("")
+    lines.append("constitution -> spec -> clarify -> review-spec -> research -> plan -> contracts -> tasks -> review-tasks -> implement -> review-impl -> docs -> done")
+    lines.append("")
+    lines.append("## Commandes disponibles")
+    lines.append("")
+
+    # Extraire commandes
+    commands_dir = root / "commands"
+    if commands_dir.is_dir():
+        for cmd_file in sorted(commands_dir.glob("devflow*.md")):
+            text = cmd_file.read_text(encoding="utf-8")
+            file_lines = text.splitlines()
+
+            # Titre
+            title = file_lines[0].lstrip("# ") if file_lines else cmd_file.stem
+            lines.append(f"### {title}")
+            lines.append("")
+
+            # Objectif
+            objective = _extract_section(text, "Objectif", max_lines=5)
+            if objective:
+                lines.append(objective)
+                lines.append("")
+
+    lines.append("## Agents")
+    lines.append("")
+
+    # Extraire agents
+    agents_dir = root / "agents"
+    if agents_dir.is_dir():
+        for agent_file in sorted(agents_dir.glob("devflow*.md")):
+            text = agent_file.read_text(encoding="utf-8")
+            basename = agent_file.stem
+
+            lines.append(f"### {basename}")
+            lines.append("")
+
+            mission = _extract_section(text, "Mission", max_lines=3)
+            if mission:
+                lines.append(mission)
+                lines.append("")
+
+    return "\n".join(lines)
+
+
+def _extract_section(text: str, section_name: str, max_lines: int = 5) -> str:
+    """Extrait le contenu d'une section markdown."""
+    pattern = rf"^## {re.escape(section_name)}\s*$"
+    match = re.search(pattern, text, re.MULTILINE)
+    if not match:
+        return ""
+
+    start = match.end()
+    remaining = text[start:].strip().splitlines()
+    result_lines: list[str] = []
+    for line in remaining:
+        if line.startswith("## "):
+            break
+        result_lines.append(line)
+        if len(result_lines) >= max_lines:
+            break
+
+    return "\n".join(result_lines).strip()
+
+
+def _export_cursor(out: Path, content: str) -> None:
+    rules_dir = out / ".cursor" / "rules"
+    rules_dir.mkdir(parents=True, exist_ok=True)
+    target = rules_dir / "devflow.mdc"
+
+    # Verifier template
+    template = get_devflow_root() / "templates" / "export" / "cursor-rules-template.md"
+    body = template.read_text(encoding="utf-8") if template.is_file() else content
+
+    frontmatter = (
+        "---\n"
+        "description: devflow workflow spec-driven\n"
+        'globs: ["docs/features/**/*", ".specify/memory/constitution.md"]\n'
+        "---\n\n"
+    )
+    target.write_text(frontmatter + body, encoding="utf-8")
+    ok(f"Export Cursor : {target}")
+
+
+def _export_copilot(out: Path, content: str) -> None:
+    github_dir = out / ".github"
+    github_dir.mkdir(parents=True, exist_ok=True)
+    target = github_dir / "copilot-instructions.md"
+
+    template = get_devflow_root() / "templates" / "export" / "copilot-instructions-template.md"
+    body = template.read_text(encoding="utf-8") if template.is_file() else content
+
+    target.write_text(body, encoding="utf-8")
+    ok(f"Export Copilot : {target}")
+
+
+def _export_windsurf(out: Path, content: str) -> None:
+    target = out / ".windsurfrules"
+
+    template = get_devflow_root() / "templates" / "export" / "cursor-rules-template.md"
+    body = template.read_text(encoding="utf-8") if template.is_file() else content
+
+    target.write_text(body, encoding="utf-8")
+    ok(f"Export Windsurf : {target}")