projscan 0.1.0__py3-none-any.whl

projscan/__init__.py

@@ -0,0 +1,26 @@
+"""projscan — scanner de dépôts git locaux et de tools uv installés.
+
+API publique importable depuis une app Textual ou tout autre code async :
+
+    from projscan import scan_paths, scan_tools, RepoInfo, ToolInfo
+
+    repos = await scan_paths([Path("~/code")], fetch=True)
+    tools = await scan_tools(check_remote=True)
+"""
+
+from __future__ import annotations
+
+from projscan.git import RepoInfo, scan_paths, scan_repo, find_repos
+from projscan.uv import ToolInfo, scan_tools, scan_tool, uv_tool_dir
+
+__all__ = [
+    "RepoInfo",
+    "scan_paths",
+    "scan_repo",
+    "find_repos",
+    "ToolInfo",
+    "scan_tools",
+    "scan_tool",
+    "uv_tool_dir",
+]
+__version__ = "0.1.0"

projscan/cli.py

@@ -0,0 +1,198 @@
+"""projscan.cli — command-line interface for projscan.
+
+Two commands:
+  projscan repos [PATHS]...   — scan folders for git repositories
+  projscan tools              — scan uv tools installed from git
+
+Exit codes:
+  0   everything up to date
+  1   at least one item needs updating (or has an error)
+  2   fatal execution error
+  130 keyboard interrupt (Ctrl-C)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from projscan.git import scan_paths
+from projscan.render import repos_table, tools_table
+from projscan.uv import scan_tools
+
+console = Console()
+err_console = Console(stderr=True)
+
+# Statuses that indicate an item needs attention
+_ACTIONABLE = frozenset(["behind", "update available", "diverged", "error"])
+
+
+def _require_git() -> None:
+    """Exit with a clear message if git is not found in PATH."""
+    if shutil.which("git") is None:
+        err_console.print("[bold red]Error:[/bold red] git is not installed or not found in PATH.")
+        err_console.print("Install git at [link]https://git-scm.com/downloads[/link] and make sure it is in your PATH.")
+        sys.exit(2)
+
+
+def _require_uv() -> None:
+    """Exit with a clear message if uv is not found in PATH."""
+    if shutil.which("uv") is None:
+        err_console.print("[bold red]Error:[/bold red] uv is not installed or not found in PATH.")
+        err_console.print("Install uv at [link]https://docs.astral.sh/uv/getting-started/installation/[/link] and make sure it is in your PATH.")
+        sys.exit(2)
+
+
+def _needs_action(status: str) -> bool:
+    return any(status == s or status.startswith(s) for s in _ACTIONABLE)
+
+
+def _exit_code(statuses: list[str]) -> int:
+    return 1 if any(_needs_action(s) for s in statuses) else 0
+
+
+@click.group()
+def _cli() -> None:
+    """projscan — git repository and uv tool scanner."""
+
+
+@_cli.command("repos")
+@click.argument("paths", nargs=-1, type=click.Path(file_okay=False))
+@click.option("--no-fetch", is_flag=True, help="Skip git fetch (use local cache).")
+@click.option("--depth", default=3, show_default=True, metavar="INTEGER", help="Max recursion depth.")
+@click.option("--json", "as_json", is_flag=True, help="JSON output (machine-readable).")
+@click.option("--concurrency", default=16, show_default=True, metavar="INTEGER", help="Max parallel scans.")
+def repos_cmd(
+    paths: tuple[str, ...],
+    no_fetch: bool,
+    depth: int,
+    as_json: bool,
+    concurrency: int,
+) -> None:
+    """Scan one or more directories and show the status of each git repository.
+
+    Defaults to the current directory if no PATH is given.
+
+    \b
+    Examples:
+      projscan repos ~/code
+      projscan repos --no-fetch --json ~/projects | jq '.[] | select(.status != "à jour")'
+    """
+    _require_git()
+    roots = [Path(p) for p in paths] if paths else [Path.cwd()]
+    try:
+        if as_json:
+            infos = asyncio.run(
+                scan_paths(roots, fetch=not no_fetch, max_depth=depth, concurrency=concurrency)
+            )
+            click.echo(json.dumps([i.as_dict() for i in infos], ensure_ascii=False, indent=2))
+        else:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                progress.add_task(
+                    f"Scanning{'  (network fetch)' if not no_fetch else ''}…",
+                    total=None,
+                )
+                infos = asyncio.run(
+                    scan_paths(roots, fetch=not no_fetch, max_depth=depth, concurrency=concurrency)
+                )
+
+            if not infos:
+                console.print("[dim]No git repositories found.[/dim]")
+                sys.exit(0)
+
+            console.print(repos_table(infos))
+
+            total = len(infos)
+            ok = sum(1 for i in infos if i.status == "up to date")
+            nok = total - ok
+            console.print(
+                f"[dim]{total} repo{'s' if total > 1 else ''}, "
+                f"{ok} up to date, {nok} to update[/dim]"
+            )
+
+        sys.exit(_exit_code([i.status for i in infos]))
+    except SystemExit:
+        raise
+    except Exception as exc:
+        err_console.print(f"[bold red]Error:[/bold red] {exc}")
+        sys.exit(2)
+
+
+@_cli.command("tools")
+@click.option("--tool-dir", "tool_dir", default=None, type=click.Path(file_okay=False), help="uv tools root (auto-detected by default).")
+@click.option("--no-remote", is_flag=True, help="Skip remote checks (list local installs only).")
+@click.option("--json", "as_json", is_flag=True, help="JSON output (machine-readable).")
+def tools_cmd(tool_dir: str | None, no_remote: bool, as_json: bool) -> None:
+    """Scan uv tools installed from git and check for updates.
+
+    \b
+    Examples:
+      projscan tools
+      projscan tools --no-remote --json
+      projscan tools --tool-dir ~/.local/share/uv/tools
+    """
+    _require_uv()
+    if not no_remote:
+        _require_git()
+    root = Path(tool_dir) if tool_dir else None
+    try:
+        if as_json:
+            infos = asyncio.run(
+                scan_tools(root, check_remote=not no_remote)
+            )
+            click.echo(json.dumps([i.as_dict() for i in infos], ensure_ascii=False, indent=2))
+        else:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                progress.add_task(
+                    f"Scanning tools{'  (checking remotes)' if not no_remote else ''}…",
+                    total=None,
+                )
+                infos = asyncio.run(
+                    scan_tools(root, check_remote=not no_remote)
+                )
+
+            if not infos:
+                console.print("[dim]No uv tools found (or uv not installed).[/dim]")
+                sys.exit(0)
+
+            console.print(tools_table(infos))
+
+            total = len(infos)
+            ok = sum(1 for i in infos if i.status == "up to date")
+            nok = total - ok
+            console.print(
+                f"[dim]{total} tool{'s' if total > 1 else ''}, "
+                f"{ok} up to date, {nok} to update[/dim]"
+            )
+
+        sys.exit(_exit_code([i.status for i in infos]))
+    except SystemExit:
+        raise
+    except Exception as exc:
+        err_console.print(f"[bold red]Error:[/bold red] {exc}")
+        sys.exit(2)
+
+
+def main() -> None:
+    """Entry point for the projscan script."""
+    try:
+        _cli()
+    except KeyboardInterrupt:
+        sys.exit(130)

projscan/git.py

@@ -0,0 +1,221 @@
+"""projscan.git — scan de dépôts git locaux pour un dashboard "suis-je à jour ?".
+
+Conçu pour être réutilisé dans un worker Textual : toutes les fonctions d'I/O sont
+async (asyncio.create_subprocess_exec), et scan_paths() parallélise via un Semaphore.
+
+Pour chaque repo trouvé on remonte :
+  - name          : nom du dossier
+  - version       : git describe --tags, sinon project.version de pyproject.toml
+  - commit        : hash court du HEAD
+  - subject / when : message + date relative du dernier commit
+  - branch        : branche courante
+  - upstream      : nom de l'upstream (ou None s'il n'y en a pas)
+  - behind / ahead : nb de commits vs upstream (None si pas d'upstream)
+  - status        : libellé synthétique (à jour / en retard / ...)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import tomllib
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+
+@dataclass
+class RepoInfo:
+    name: str
+    path: str
+    version: str | None
+    commit: str | None
+    subject: str | None
+    when: str | None
+    branch: str | None
+    upstream: str | None
+    behind: int | None
+    ahead: int | None
+    status: str
+    error: str | None = None
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+async def _git(repo: Path, *args: str, timeout: float = 30.0) -> tuple[int, str, str]:
+    """Lance une commande git dans `repo`. Renvoie (returncode, stdout, stderr)."""
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        "-C",
+        str(repo),
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return 124, "", "timeout"
+    return proc.returncode, out.decode(errors="replace").strip(), err.decode(errors="replace").strip()
+
+
+def is_git_repo(path: Path) -> bool:
+    """Un dépôt git "racine" : présence d'un .git (dossier classique ou worktree)."""
+    return (path / ".git").exists()
+
+
+def _read_pyproject_version(repo: Path) -> str | None:
+    pp = repo / "pyproject.toml"
+    if not pp.is_file():
+        return None
+    try:
+        data = tomllib.loads(pp.read_text(encoding="utf-8"))
+    except (tomllib.TOMLDecodeError, OSError):
+        return None
+    # project.version (PEP 621) puis tool.poetry.version en repli
+    v = data.get("project", {}).get("version")
+    if v:
+        return str(v)
+    v = data.get("tool", {}).get("poetry", {}).get("version")
+    return str(v) if v else None
+
+
+async def _version(repo: Path) -> str | None:
+    """git describe --tags si possible, sinon la version du pyproject."""
+    rc, out, _ = await _git(repo, "describe", "--tags", "--always", "--dirty")
+    if rc == 0 and out:
+        # describe renvoie le hash court s'il n'y a aucun tag ; dans ce cas on
+        # préfère pyproject s'il existe, sinon on garde le hash.
+        py = _read_pyproject_version(repo)
+        # heuristique : si describe ne ressemble pas à un tag (pas de chiffre.point)
+        # et qu'on a une version pyproject, on prend pyproject.
+        looks_like_tag = any(c.isdigit() for c in out) and "." in out
+        if looks_like_tag:
+            return out
+        if py:
+            return py
+        return out
+    return _read_pyproject_version(repo)
+
+
+async def scan_repo(path: Path, *, fetch: bool = True) -> RepoInfo:
+    """Scanne un dépôt unique. Si fetch=True, met à jour les refs distantes d'abord."""
+    name = path.name
+    try:
+        if fetch:
+            # --quiet, ignore les erreurs (offline, pas de remote, auth...) :
+            # on continue avec les refs locales.
+            await _git(path, "fetch", "--quiet", "--all", timeout=60.0)
+
+        rc, log, _ = await _git(path, "log", "-1", "--format=%h%x1f%s%x1f%cr")
+        commit = subject = when = None
+        if rc == 0 and log:
+            parts = log.split("\x1f")
+            commit = parts[0] if len(parts) > 0 else None
+            subject = parts[1] if len(parts) > 1 else None
+            when = parts[2] if len(parts) > 2 else None
+
+        _, branch, _ = await _git(path, "rev-parse", "--abbrev-ref", "HEAD")
+        branch = branch or None
+
+        rc_up, upstream, _ = await _git(
+            path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"
+        )
+        upstream = upstream if rc_up == 0 and upstream else None
+
+        behind = ahead = None
+        if upstream:
+            rc_c, counts, _ = await _git(
+                path, "rev-list", "--left-right", "--count", "HEAD...@{u}"
+            )
+            if rc_c == 0 and counts:
+                # format : "<ahead>\t<behind>" (gauche=HEAD, droite=upstream)
+                a, _, b = counts.partition("\t")
+                try:
+                    ahead, behind = int(a.strip()), int(b.strip())
+                except ValueError:
+                    pass
+
+        version = await _version(path)
+
+        status = _status_label(upstream, behind, ahead)
+        return RepoInfo(
+            name=name,
+            path=str(path),
+            version=version,
+            commit=commit,
+            subject=subject,
+            when=when,
+            branch=branch,
+            upstream=upstream,
+            behind=behind,
+            ahead=ahead,
+            status=status,
+        )
+    except Exception as exc:  # robustesse : un repo cassé ne doit pas tuer le scan
+        return RepoInfo(
+            name=name, path=str(path), version=None, commit=None, subject=None,
+            when=None, branch=None, upstream=None, behind=None, ahead=None,
+            status="error", error=f"{type(exc).__name__}: {exc}",
+        )
+
+
+def _status_label(upstream: str | None, behind: int | None, ahead: int | None) -> str:
+    if upstream is None:
+        return "no upstream"
+    if behind is None or ahead is None:
+        return "unknown"
+    if behind and ahead:
+        return f"diverged (↓{behind} ↑{ahead})"
+    if behind:
+        return f"behind (↓{behind})"
+    if ahead:
+        return f"ahead (↑{ahead})"
+    return "up to date"
+
+
+def find_repos(roots: list[Path], *, max_depth: int = 3) -> list[Path]:
+    """Parcourt récursivement les racines et renvoie tous les dépôts git.
+
+    S'arrête de descendre dès qu'un .git est trouvé (on ne scanne pas l'intérieur
+    d'un repo). max_depth limite la profondeur pour éviter d'exploser sur un home.
+    """
+    found: list[Path] = []
+    seen: set[Path] = set()
+
+    def walk(d: Path, depth: int) -> None:
+        if depth > max_depth or d in seen:
+            return
+        seen.add(d)
+        if is_git_repo(d):
+            found.append(d)
+            return  # ne pas descendre dans un repo
+        try:
+            children = [c for c in d.iterdir() if c.is_dir() and not c.is_symlink()]
+        except (PermissionError, OSError):
+            return
+        for c in children:
+            if c.name in {".git", "node_modules", "__pycache__", ".venv", "venv"}:
+                continue
+            walk(c, depth + 1)
+
+    for root in roots:
+        root = Path(root).expanduser()
+        if root.is_dir():
+            walk(root, 0)
+    return sorted(found)
+
+
+async def scan_paths(
+    roots: list[Path], *, fetch: bool = True, max_depth: int = 3, concurrency: int = 16
+) -> list[RepoInfo]:
+    """Trouve et scanne tous les repos sous `roots`, en parallèle (borné)."""
+    repos = find_repos(roots, max_depth=max_depth)
+    sem = asyncio.Semaphore(concurrency)
+
+    async def bounded(p: Path) -> RepoInfo:
+        async with sem:
+            return await scan_repo(p, fetch=fetch)
+
+    return list(await asyncio.gather(*(bounded(p) for p in repos)))

projscan/render.py

@@ -0,0 +1,129 @@
+"""projscan.render — rendu Rich partagé entre les deux commandes CLI.
+
+Toutes les fonctions retournent des objets Rich (Table, Text) sans écrire
+directement dans la console, pour pouvoir être réutilisées dans Textual.
+"""
+
+from __future__ import annotations
+
+from rich import box
+from rich.table import Table
+from rich.text import Text
+
+from projscan.git import RepoInfo
+from projscan.uv import ToolInfo
+
+# Mapping status -> Rich style. Variable-prefix statuses (behind / diverged)
+# are handled by status_style() below.
+_STATUS_STYLES: dict[str, str] = {
+    "up to date": "green",
+    "ahead": "cyan",
+    "update available": "yellow",
+    "no upstream": "dim",
+    "not git": "dim",
+    "unknown": "dim",
+    "error": "bold red",
+}
+
+# Display priority: actionable items bubble to the top.
+_STATUS_PRIORITY: dict[str, int] = {
+    "error": 0,
+    "behind": 1,
+    "update available": 2,
+    "diverged": 3,
+    "unknown": 4,
+    "ahead": 5,
+    "no upstream": 6,
+    "not git": 7,
+    "up to date": 8,
+}
+
+
+def status_style(status: str) -> str:
+    """Return the Rich style corresponding to the given status string."""
+    if status.startswith("behind"):
+        return "red"
+    if status.startswith("diverged"):
+        return "magenta"
+    if status.startswith("ahead"):
+        return "cyan"
+    return _STATUS_STYLES.get(status, "dim")
+
+
+def _sort_priority(status: str) -> int:
+    for prefix, priority in _STATUS_PRIORITY.items():
+        if status == prefix or status.startswith(prefix):
+            return priority
+    return 9
+
+
+def _shorten_url(url: str) -> str:
+    """Retire le schéma d'une URL pour économiser de la place."""
+    if "://" in url:
+        _, _, rest = url.partition("://")
+        return rest
+    return url
+
+
+def repos_table(infos: list[RepoInfo]) -> Table:
+    """Construit une Table Rich pour les RepoInfo, triée par priorité d'action."""
+    table = Table(
+        box=box.ROUNDED,
+        show_header=True,
+        header_style="bold",
+        expand=False,
+        highlight=False,
+    )
+    table.add_column("Name", style="bold", no_wrap=True, min_width=12)
+    table.add_column("Version", no_wrap=True)
+    table.add_column("Branch", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Commit", no_wrap=True, style="dim")
+    table.add_column("Message", max_width=48)
+    table.add_column("When", no_wrap=True, style="dim")
+
+    sorted_infos = sorted(infos, key=lambda r: (_sort_priority(r.status), r.name.lower()))
+
+    for r in sorted_infos:
+        table.add_row(
+            r.name,
+            r.version or "",
+            r.branch or "",
+            Text(r.status, style=status_style(r.status)),
+            r.commit or "",
+            r.subject or "",
+            r.when or "",
+        )
+    return table
+
+
+def tools_table(infos: list[ToolInfo]) -> Table:
+    """Construit une Table Rich pour les ToolInfo, triée par priorité d'action."""
+    table = Table(
+        box=box.ROUNDED,
+        show_header=True,
+        header_style="bold",
+        expand=False,
+        highlight=False,
+    )
+    table.add_column("Name", style="bold", no_wrap=True, min_width=12)
+    table.add_column("Version", no_wrap=True)
+    table.add_column("Source", max_width=40)
+    table.add_column("Ref", no_wrap=True)
+    table.add_column("Commit", no_wrap=True, style="dim")
+    table.add_column("Status", no_wrap=True)
+
+    sorted_infos = sorted(infos, key=lambda t: (_sort_priority(t.status), t.name.lower()))
+
+    for t in sorted_infos:
+        url_short = _shorten_url(t.url) if t.url else ""
+        commit_short = (t.installed_commit or "")[:8]
+        table.add_row(
+            t.name,
+            t.version or "",
+            url_short,
+            t.ref or "",
+            commit_short,
+            Text(t.status, style=status_style(t.status)),
+        )
+    return table

projscan/uv.py

@@ -0,0 +1,339 @@
+"""projscan.uv — scan des outils installés par `uv tool` depuis des sources git.
+
+Objectif : pour chaque tool installé via `uv tool install git+https://...`,
+savoir s'il est à jour par rapport à la branche/ref distante, SANS cloner.
+
+Stratégie :
+  1. localiser la racine des tools (`uv tool dir`, repli sur les chemins connus)
+  2. pour chaque tool, retrouver l'URL git + le commit installé + la ref demandée
+       - source fiable : uv-receipt.toml (métadonnées uv)
+       - repli PEP 610 : <venv>/.../<pkg>-*.dist-info/direct_url.json
+  3. interroger le HEAD distant via `git ls-remote <url> <ref>` (1 requête, 0 objet)
+  4. comparer : installed_commit == remote_commit -> à jour, sinon MAJ dispo
+
+Pensé pour Textual : fonctions d'I/O async, scan parallèle borné, dataclass.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import tomllib
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+
+@dataclass
+class ToolInfo:
+    name: str
+    version: str | None
+    url: str | None            # URL git source (None si non-git / PyPI)
+    ref: str | None            # branche/tag demandé (ex "main"), peut être None
+    installed_commit: str | None
+    remote_commit: str | None
+    status: str                # à jour / MAJ dispo / inconnu / pas git / erreur
+    error: str | None = None
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+# --- localisation de la racine uv tools --------------------------------------
+
+async def uv_tool_dir() -> Path | None:
+    """Racine des environnements de tools uv (ex ~/.local/share/uv/tools)."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "uv", "tool", "dir",
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+        )
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout=15.0)
+        if proc.returncode == 0:
+            p = Path(out.decode().strip())
+            if p.is_dir():
+                return p
+    except (FileNotFoundError, asyncio.TimeoutError):
+        pass
+    # replis usuels
+    for cand in (
+        os.environ.get("UV_TOOL_DIR"),
+        "~/.local/share/uv/tools",
+        "~/Library/Application Support/uv/tools",  # macOS
+    ):
+        if cand:
+            p = Path(cand).expanduser()
+            if p.is_dir():
+                return p
+    return None
+
+
+# --- extraction des infos d'installation -------------------------------------
+
+def _parse_direct_url(data: dict) -> dict:
+    """Extrait url/commit/ref d'un direct_url.json (PEP 610)."""
+    url = data.get("url")
+    vcs = data.get("vcs_info") or {}
+    return {
+        "url": url,
+        "installed_commit": vcs.get("commit_id"),
+        "ref": vcs.get("requested_revision"),  # peut être absent
+    }
+
+
+def _read_dist_info_version(tool_path: Path) -> str | None:
+    """Lit la version installée depuis *.dist-info/METADATA (header PEP 566 'Version:').
+
+    Fallback universel : couvre les tools PyPI où le receipt ne stocke pas la version.
+    """
+    for dist_info in tool_path.rglob("*.dist-info"):
+        metadata = dist_info / "METADATA"
+        if not metadata.is_file():
+            continue
+        try:
+            for line in metadata.read_text(encoding="utf-8", errors="replace").splitlines():
+                if line.lower().startswith("version:"):
+                    return line.split(":", 1)[1].strip()
+        except OSError:
+            continue
+    return None
+
+
+def _find_direct_url_json(tool_path: Path) -> dict | None:
+    """Cherche un direct_url.json dans le venv du tool (layout uv variable)."""
+    # uv place le venv soit directement dans tool_path, soit dans un sous-dossier.
+    for dist_info in tool_path.rglob("*.dist-info"):
+        du = dist_info / "direct_url.json"
+        if du.is_file():
+            try:
+                return json.loads(du.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                continue
+    return None
+
+
+def _read_receipt(tool_path: Path) -> dict | None:
+    """Lit uv-receipt.toml et tente d'en extraire url/commit/ref + version.
+
+    Le schéma du receipt a évolué selon les versions d'uv ; on reste tolérant
+    et on récupère ce qu'on peut, peu importe l'emplacement exact des clés.
+    """
+    receipt = tool_path / "uv-receipt.toml"
+    if not receipt.is_file():
+        return None
+    try:
+        data = tomllib.loads(receipt.read_text(encoding="utf-8"))
+    except (tomllib.TOMLDecodeError, OSError):
+        return None
+
+    found: dict = {"url": None, "installed_commit": None, "ref": None, "version": None}
+
+    def walk(obj: object) -> None:
+        if isinstance(obj, dict):
+            # clés git possibles selon les versions d'uv
+            for k, v in obj.items():
+                if isinstance(v, str):
+                    lk = k.lower()
+                    # clé "git" explicite -> on prend la valeur telle quelle
+                    # (couvre les URLs http(s)/ssh ET les chemins git locaux).
+                    if lk == "git" and v:
+                        found["url"] = found["url"] or v
+                    elif lk in {"url", "repository"} and (
+                        "://" in v or v.startswith("git@") or v.endswith(".git")
+                    ):
+                        found["url"] = found["url"] or v
+                    elif lk in {"rev", "commit", "commit_id", "precise"} and _looks_like_sha(v):
+                        found["installed_commit"] = found["installed_commit"] or v
+                    elif lk in {"reference", "requested_revision", "branch", "tag", "ref"}:
+                        found["ref"] = found["ref"] or v
+                    elif lk == "version":
+                        found["version"] = found["version"] or v
+            for v in obj.values():
+                walk(v)
+        elif isinstance(obj, list):
+            for v in obj:
+                walk(v)
+
+    walk(data)
+    return found
+
+
+def _looks_like_sha(s: str) -> bool:
+    return 7 <= len(s) <= 40 and all(c in "0123456789abcdef" for c in s.lower())
+
+
+def _split_git_url(raw: str) -> tuple[str, str | None]:
+    """Sépare une URL git de sa ref encodée.
+
+    uv (et pip) encodent parfois la ref dans l'URL :
+      - https://host/repo.git?rev=main      -> (https://host/repo.git, "main")
+      - https://host/repo.git@v1.2          -> (https://host/repo.git, "v1.2")
+      - https://host/repo.git#main          -> (https://host/repo.git, "main")
+      - git+https://host/repo.git           -> (https://host/repo.git, None)
+    Renvoie (url_propre, ref|None). ls-remote a besoin de l'URL SANS la ref.
+    """
+    ref: str | None = None
+    url = raw.strip()
+
+    # préfixe pip "git+"
+    if url.startswith("git+"):
+        url = url[4:]
+
+    # ?rev=... ou &rev=... (paramètre de requête)
+    for sep in ("?", "&"):
+        if sep in url:
+            base, _, query = url.partition(sep)
+            for part in query.split("&"):
+                k, _, v = part.partition("=")
+                if k in {"rev", "ref", "branch", "tag"} and v:
+                    ref = ref or v
+            # on retire toute la query de l'URL
+            url = base
+
+    # fragment #ref
+    if "#" in url:
+        url, _, frag = url.partition("#")
+        # fragments du style "egg=...&subdirectory=..." : ignorer; sinon = ref
+        if frag and "=" not in frag:
+            ref = ref or frag
+
+    # suffixe @ref (après le .git), mais PAS le @ de git@host (scp-like)
+    # on ne traite le @ que s'il suit ".git"
+    git_at = url.rfind(".git@")
+    if git_at != -1:
+        ref = ref or url[git_at + len(".git@"):]
+        url = url[: git_at + len(".git")]
+
+    return url, ref
+
+
+def read_install_info(tool_path: Path) -> dict:
+    """Combine receipt (prioritaire) et direct_url.json (repli/complément)."""
+    info: dict = {"url": None, "installed_commit": None, "ref": None, "version": None}
+
+    receipt = _read_receipt(tool_path)
+    if receipt:
+        for k in info:
+            info[k] = info[k] or receipt.get(k)
+
+    # complète les trous avec direct_url.json
+    if not all((info["url"], info["installed_commit"])):
+        du = _find_direct_url_json(tool_path)
+        if du:
+            parsed = _parse_direct_url(du)
+            for k in ("url", "installed_commit", "ref"):
+                info[k] = info[k] or parsed.get(k)
+
+    # nettoie l'URL (retire ?rev=/@ref/#frag) et récupère la ref encodée s'il
+    # n'y en avait pas. ls-remote a besoin de l'URL nue.
+    if info["url"]:
+        clean_url, url_ref = _split_git_url(info["url"])
+        info["url"] = clean_url
+        info["ref"] = info["ref"] or url_ref
+
+    # dernier recours : lire la version depuis dist-info/METADATA
+    if not info["version"]:
+        info["version"] = _read_dist_info_version(tool_path)
+    return info
+
+
+# --- HEAD distant sans clone -------------------------------------------------
+
+async def remote_head(url: str, ref: str | None = None, *, timeout: float = 30.0) -> str | None:
+    """SHA du HEAD distant via ls-remote. ref None -> HEAD par défaut du repo."""
+    args = ["git", "ls-remote", url]
+    if ref:
+        args.append(ref)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+            env={**os.environ, "GIT_TERMINAL_PROMPT": "0"},  # pas de prompt auth
+        )
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except (asyncio.TimeoutError, FileNotFoundError):
+        return None
+    if proc.returncode != 0:
+        return None
+    text = out.decode(errors="replace").strip()
+    if not text:
+        return None
+    # ls-remote peut renvoyer plusieurs lignes (ex refs/heads/main + refs/tags).
+    # On préfère une ligne refs/heads/<ref> si ref donné, sinon la 1re.
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    if ref:
+        for ln in lines:
+            sha, _, name = ln.partition("\t")
+            if name.endswith(f"refs/heads/{ref}") or name == ref:
+                return sha.strip()
+    return lines[0].split("\t")[0].strip()
+
+
+def _same_commit(a: str | None, b: str | None) -> bool:
+    """Compare deux SHA possiblement de longueurs différentes (court vs long)."""
+    if not a or not b:
+        return False
+    a, b = a.lower(), b.lower()
+    n = min(len(a), len(b))
+    return n >= 7 and a[:n] == b[:n]
+
+
+# --- scan d'un tool ----------------------------------------------------------
+
+async def scan_tool(name: str, tool_path: Path, *, check_remote: bool = True) -> ToolInfo:
+    """Scanne un tool uv installé et détermine si une mise à jour est disponible."""
+    try:
+        info = read_install_info(tool_path)
+        url = info["url"]
+        installed = info["installed_commit"]
+        ref = info["ref"]
+        version = info["version"]
+
+        if not url:
+            return ToolInfo(name, version, None, None, installed, None, "not git")
+
+        remote = None
+        if check_remote:
+            remote = await remote_head(url, ref)
+
+        if remote is None:
+            status = "unknown"  # offline, auth, repo privé...
+        elif _same_commit(installed, remote):
+            status = "up to date"
+        else:
+            status = "update available"
+
+        return ToolInfo(name, version, url, ref, installed, remote, status)
+    except Exception as exc:
+        return ToolInfo(name, None, None, None, None, None, "error",
+                        error=f"{type(exc).__name__}: {exc}")
+
+
+def find_tools(tools_root: Path) -> list[tuple[str, Path]]:
+    """Liste (nom, chemin) des tools : chaque sous-dossier direct de la racine."""
+    out: list[tuple[str, Path]] = []
+    try:
+        for d in sorted(tools_root.iterdir()):
+            if d.is_dir() and not d.name.startswith("."):
+                out.append((d.name, d))
+    except (OSError, PermissionError):
+        pass
+    return out
+
+
+async def scan_tools(
+    tools_root: Path | None = None, *, check_remote: bool = True, concurrency: int = 16
+) -> list[ToolInfo]:
+    """Scanne tous les uv tools. Trouve la racine automatiquement si non fournie."""
+    root = tools_root or await uv_tool_dir()
+    if root is None:
+        return []
+    tools = find_tools(root)
+    sem = asyncio.Semaphore(concurrency)
+
+    async def bounded(item: tuple[str, Path]) -> ToolInfo:
+        name, path = item
+        async with sem:
+            return await scan_tool(name, path, check_remote=check_remote)
+
+    return list(await asyncio.gather(*(bounded(t) for t in tools)))

projscan-0.1.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: projscan
+Version: 0.1.0
+Summary: Scanner de dépôts git locaux et de tools uv installés.
+Requires-Python: >=3.11
+Requires-Dist: click>=8
+Requires-Dist: rich>=13
+Description-Content-Type: text/markdown
+
+# projscan
+
+Scanner de dépôts git locaux et de tools `uv` installés depuis git.  
+Répond à une question simple : **suis-je à jour ?**
+
+## Installation
+
+```bash
+uv tool install git+https://github.com/Caymaar/projscan.git
+```
+
+Ou en mode développement :
+
+```bash
+git clone ...
+cd projscan
+uv sync
+uv run projscan --help
+```
+
+## Commandes
+
+### `projscan repos [PATHS]...`
+
+Scanne récursivement un ou plusieurs dossiers et affiche l'état de chaque dépôt git.
+
+```
+╭──────────────────────┬─────────┬─────────┬─────────────────────┬────────┬────────────────────┬─────────────╮
+│ Nom                  │ Version │ Branche │ Statut              │ Commit │ Message            │ Quand       │
+├──────────────────────┼─────────┼─────────┼─────────────────────┼────────┼────────────────────┼─────────────┤
+│ mon-api              │ 2.1.0   │ main    │ en retard (↓3)      │ a4f2c1 │ fix: timeout retry │ 2 days ago  │
+│ mon-dashboard        │ 1.0.0   │ main    │ divergé (↓1 ↑2)     │ b8e3d9 │ feat: dark mode    │ 5 hours ago │
+│ projscan             │ 0.1.0   │ main    │ à jour              │ c1a2b3 │ initial commit     │ 1 hour ago  │
+╰──────────────────────┴─────────┴─────────┴─────────────────────┴────────┴────────────────────┴─────────────╯
+3 repos, 1 à jour, 2 à mettre à jour
+```
+
+**Options :**
+
+| Option | Description |
+|--------|-------------|
+| `--no-fetch` | Ne pas faire `git fetch` — utilise le cache local (rapide) |
+| `--depth INTEGER` | Profondeur max de récursion (défaut : 3) |
+| `--json` | Sortie JSON machine-readable |
+| `--concurrency INTEGER` | Scans parallèles (défaut : 16) |
+
+```bash
+# Scanne ~/code et ~/work
+projscan repos ~/code ~/work
+
+# Rapide, sans réseau
+projscan repos --no-fetch ~/code
+
+# Pipe JSON vers jq
+projscan repos --no-fetch --json ~/code | jq '.[] | select(.status != "à jour")'
+```
+
+### `projscan tools`
+
+Scanne les tools installés via `uv tool install git+https://...` et vérifie si des mises à jour sont disponibles (via `git ls-remote`, sans cloner).
+
+```
+╭────────────────┬─────────┬───────────────────────────────┬────────┬──────────┬───────────╮
+│ Nom            │ Version │ Source                        │ Ref    │ Commit   │ Statut    │
+├────────────────┼─────────┼───────────────────────────────┼────────┼──────────┼───────────┤
+│ mon-tool       │ 1.2.0   │ github.com/org/mon-tool.git   │ main   │ f10c2123 │ MAJ dispo │
+│ autre-tool     │ 0.9.1   │ github.com/org/autre-tool.git │ main   │ fc9e74c5 │ à jour    │
+╰────────────────┴─────────┴───────────────────────────────┴────────┴──────────┴───────────╯
+2 tools, 1 à jour, 1 à mettre à jour
+```
+
+**Options :**
+
+| Option | Description |
+|--------|-------------|
+| `--tool-dir PATH` | Racine des tools uv (détection auto par défaut) |
+| `--no-remote` | Liste locale sans vérifier les remotes |
+| `--json` | Sortie JSON machine-readable |
+
+```bash
+projscan tools
+projscan tools --no-remote --json
+projscan tools --tool-dir ~/.local/share/uv/tools
+```
+
+## Codes de sortie
+
+| Code | Signification |
+|------|---------------|
+| `0`  | Tout est à jour |
+| `1`  | Au moins un item à mettre à jour (ou en erreur) |
+| `2`  | Erreur d'exécution fatale |
+| `130` | Interruption clavier (Ctrl-C) |
+
+Utile en script ou en CI :
+
+```bash
+projscan repos --no-fetch ~/code || echo "Des repos sont en retard !"
+```
+
+## Couleurs de statut
+
+| Statut | Couleur | Signification |
+|--------|---------|---------------|
+| `à jour` | vert | Synchronisé avec l'upstream |
+| `en retard (↓N)` | rouge | N commits distants non récupérés |
+| `en avance (↑N)` | cyan | N commits locaux non poussés |
+| `divergé (↓N ↑M)` | magenta | Branches divergées |
+| `MAJ dispo` | jaune | Nouvelle version du tool disponible |
+| `pas d'upstream` | gris | Pas de tracking branch configurée |
+| `pas git` | gris | Tool installé depuis PyPI, pas git |
+| `inconnu` | gris | Remote inaccessible (offline, auth...) |
+| `erreur` | rouge gras | Erreur lors du scan |
+
+## Usage comme bibliothèque
+
+`projscan` est conçu pour être importé dans une app Textual ou tout autre code async.
+
+```python
+from pathlib import Path
+from projscan import scan_paths, scan_tools, RepoInfo, ToolInfo
+
+# Scanne des dépôts git
+repos: list[RepoInfo] = await scan_paths(
+    [Path("~/code")],
+    fetch=True,
+    max_depth=3,
+    concurrency=16,
+)
+
+for repo in repos:
+    print(f"{repo.name}: {repo.status}")
+
+# Scanne les tools uv
+tools: list[ToolInfo] = await scan_tools(check_remote=True)
+
+for tool in tools:
+    if tool.status == "MAJ dispo":
+        print(f"Update available: {tool.name}")
+```
+
+Les dataclasses exposent une méthode `.as_dict()` pour la sérialisation JSON :
+
+```python
+import json
+print(json.dumps([r.as_dict() for r in repos], ensure_ascii=False))
+```
+
+L'API publique complète :
+
+```python
+from projscan import (
+    # Git
+    RepoInfo, scan_paths, scan_repo, find_repos,
+    # UV tools
+    ToolInfo, scan_tools, scan_tool, uv_tool_dir,
+)
+```
+
+## Développement
+
+```bash
+uv sync
+uv run pytest           # 52 tests, ~5s
+uv run projscan repos . # test en réel
+uv run projscan tools   # test en réel
+```

projscan-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+projscan/__init__.py,sha256=sgqrRDKm3sj7qobhadsH1pYMYKU4e7ZbNspChXRgZkg,681
+projscan/cli.py,sha256=UNUDJVgQKff10t-hr6A2_dMMC2tgJGS4ESA4W0ThG2s,6813
+projscan/git.py,sha256=lwkziO-7012gbFc6fDPs-zSoqisJLaG5WHLhBM8q8E8,7709
+projscan/render.py,sha256=PFwhsXzS-403YVDwIbu06n_mPttvh-6PETE7nbmUgbo,3846
+projscan/uv.py,sha256=1_kX00NN09AbV5JnK_J-5iUcWI5O2w7A1eMpwpmsvYA,12521
+projscan-0.1.0.dist-info/METADATA,sha256=9uq6XIvWIQIb3edHzp1BztmgWK85NCtsoGuZWSOlbDA,6670
+projscan-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+projscan-0.1.0.dist-info/entry_points.txt,sha256=hH1yaUyPwyyS06ICDTfBAyOF3AnjaDsPimiYgwq1WpI,47
+projscan-0.1.0.dist-info/RECORD,,

projscan-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

projscan-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+projscan = projscan.cli:main