codedna 0.3.2__tar.gz → 0.3.4__tar.gz

{codedna-0.3.2 → codedna-0.3.4}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.3.4] - 2026-06-24 — "Doctor Redesign"
+
+### 🎨 Redesigned
+- **`codedna doctor` — rich Table + Panel layout** matching the legacy CodeDNA CLI style
+  - Header Panel with version + plan info (`border_style="cyan"`)
+  - Animated spinner during checks (`console.status`, dots spinner)
+  - Rich Table with `show_lines=True`, header_style cyan
+  - Color-coded status column: ✓ green, ⚠ yellow, ✗ red, – dim
+  - Summary Panel with color-coded border (green / yellow / red)
+  - 9 categories, 19 individual checks
+
+## [0.3.3] - 2026-06-24 — "One-Command Update"
+
+### ✨ Added
+- **`codedna update` command** — self-upgrade from PyPI in a single command
+  - `codedna update` — upgrade to latest version
+  - `codedna update --check` — only check, do not install
+  - `codedna update --target 0.3.2` — install a specific version
+  - Auto-detects installer (`uv` first, falls back to `pip`)
+  - Verifies new version after install
+  - User no longer needs to remember `pip install --upgrade` or PATH dance
+- **`codedna update --check` exit code** — 0 if up-to-date, 1 if update available (CI-friendly)
+
 ## [0.3.2] - 2026-06-24 — "Windows PATH Fix"
 
 ### 📚 Documentation

{codedna-0.3.2 → codedna-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.3.2
+Version: 0.3.4
 Summary: AI Code Transparency Tool - detect AI-written code and measure developer understanding
 Project-URL: Homepage, https://codedna.dev
 Project-URL: Repository, https://github.com/natureco-official/codedna

{codedna-0.3.2 → codedna-0.3.4}/codedna/__init__.py

@@ -1,4 +1,4 @@
 """CodeDNA — AI Code Transparency Tool."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 __app_name__ = "codedna"

{codedna-0.3.2 → codedna-0.3.4}/codedna/cli.py

@@ -1710,180 +1710,312 @@ def doctor(
 ) -> None:
     """Run a system health check (Python, Git, tree-sitter, DB, hook, API, network)."""
 
-    def _ok(msg: str) -> None:
-        console.print(f"  [green]✓[/green] {msg}")
-
-    def _warn(msg: str) -> None:
-        console.print(f"  [yellow]![/yellow] {msg}")
-
-    def _fail(msg: str) -> None:
-        console.print(f"  [red]✗[/red] {msg}")
-
-    console.print(Panel.fit("🧬 CodeDNA — System Health Check", style="bold cyan"))
+    console.print()
+    console.print(
+        Panel.fit(
+            "[bold cyan]🧬 CodeDNA — System Health Check[/bold cyan]\n"
+            f"[dim]Version: {__version__} · Plan: detecting...[/dim]",
+            border_style="cyan",
+            padding=(1, 4),
+        )
+    )
     console.print()
 
     issues: list[str] = []
     warnings: list[str] = []
+    checks: list[tuple[str, str, str]] = []  # (category, status, message)
 
-    # 1. Python version
-    console.print("[bold]1. Python Environment[/bold]")
-    py_ver = sys.version_info
-    if py_ver >= (3, 10):
-        _ok(f"Python {py_ver.major}.{py_ver.minor}.{py_ver.micro} (>= 3.10 required)")
-    else:
-        _fail(f"Python {py_ver.major}.{py_ver.minor}.{py_ver.micro} — 3.10+ required")
-        issues.append("python_version")
-
-    # 2. CodeDNA installation
-    try:
-        import codedna
-        _ok(f"CodeDNA {codedna.__version__} installed at {Path(codedna.__file__).parent}")
-    except Exception as e:
-        _fail(f"CodeDNA import failed: {e}")
-        issues.append("codedna_import")
+    def _record(category: str, status: str, message: str) -> None:
+        """status: 'ok' | 'warn' | 'fail'"""
+        checks.append((category, status, message))
+        if status == "fail":
+            issues.append(f"{category}: {message}")
+        elif status == "warn":
+            warnings.append(f"{category}: {message}")
 
-    # 3. Git
-    console.print()
-    console.print("[bold]2. Git Integration[/bold]")
-    try:
+    with console.status("[bold cyan]🔍 Running health checks...[/bold cyan]", spinner="dots"):
         import subprocess
-        result = subprocess.run(["git", "--version"], capture_output=True, text=True, timeout=5)
-        if result.returncode == 0:
-            _ok(f"Git: {result.stdout.strip()}")
+
+        # 1. Python Environment
+        py_ver = sys.version_info
+        if py_ver >= (3, 10):
+            _record("Python", "ok", f"{py_ver.major}.{py_ver.minor}.{py_ver.micro} (≥ 3.10 required)")
         else:
-            _fail("Git not available")
-            issues.append("git")
-    except FileNotFoundError:
-        _fail("Git not found on PATH")
-        issues.append("git")
-    except Exception as e:
-        _warn(f"Git check failed: {e}")
-        warnings.append("git_check")
+            _record("Python", "fail", f"{py_ver.major}.{py_ver.minor}.{py_ver.micro} — 3.10+ required")
 
-    # 4. Tree-sitter parsers
-    console.print()
-    console.print("[bold]3. Tree-sitter Parsers[/bold]")
-    parsers = [
-        ("tree_sitter", "tree-sitter"),
-        ("tree_sitter_python", "tree-sitter-python"),
-        ("tree_sitter_javascript", "tree-sitter-javascript"),
-        ("tree_sitter_typescript", "tree-sitter-typescript"),
-    ]
-    for mod_name, pkg_name in parsers:
+        # 2. CodeDNA installation
         try:
-            __import__(mod_name)
-            _ok(f"{pkg_name}")
-        except ImportError:
-            _fail(f"{pkg_name} — not installed")
-            issues.append(f"missing:{pkg_name}")
+            import codedna
+            _record("CodeDNA", "ok", f"v{codedna.__version__} at {Path(codedna.__file__).parent}")
+        except Exception as e:
+            _record("CodeDNA", "fail", f"import failed: {e}")
 
-    # 5. Database (only if in a git repo)
-    console.print()
-    console.print("[bold]4. Local Database[/bold]")
-    try:
-        root = repo or find_git_root()
-        db_path = get_db_path(root)
-        if db_path.exists():
-            size_kb = db_path.stat().st_size / 1024
-            _ok(f"Database at {db_path} ({size_kb:.1f} KB)")
-        else:
-            _warn(f"No database at {db_path} (run `codedna init` to create)")
-            warnings.append("no_db")
-            if fix:
-                try:
-                    init_db(db_path)
-                    _ok("Database initialized")
-                except Exception as e:
-                    _fail(f"Could not create database: {e}")
-                    issues.append("db_init_failed")
-    except Exception:
-        _warn("Not in a git repo — database check skipped")
+        # 3. Git
+        try:
+            result = subprocess.run(["git", "--version"], capture_output=True, text=True, timeout=5)
+            if result.returncode == 0:
+                _record("Git", "ok", result.stdout.strip())
+            else:
+                _record("Git", "fail", "git command returned non-zero")
+        except FileNotFoundError:
+            _record("Git", "fail", "git not found on PATH")
+        except Exception as e:
+            _record("Git", "warn", f"check failed: {e}")
+
+        # 4. Tree-sitter parsers
+        parsers = [
+            ("tree_sitter", "tree-sitter"),
+            ("tree_sitter_python", "tree-sitter-python"),
+            ("tree_sitter_javascript", "tree-sitter-javascript"),
+            ("tree_sitter_typescript", "tree-sitter-typescript"),
+        ]
+        for mod_name, pkg_name in parsers:
+            try:
+                __import__(mod_name)
+                _record("Tree-sitter", "ok", pkg_name)
+            except ImportError:
+                _record("Tree-sitter", "fail", f"{pkg_name} not installed")
+
+        # 5. Database
+        db_status = "skip"
+        db_msg = "Not in a git repo"
+        db_path: Optional[Path] = None
+        try:
+            root = repo or find_git_root()
+            db_path = get_db_path(root)
+            if db_path.exists():
+                size_kb = db_path.stat().st_size / 1024
+                _record("Database", "ok", f"{db_path} ({size_kb:.1f} KB)")
+                db_status = "ok"
+                db_msg = f"{db_path} ({size_kb:.1f} KB)"
+            else:
+                _record("Database", "warn", f"no database at {db_path}")
+                db_status = "warn"
+                db_msg = "not initialized"
+                if fix:
+                    try:
+                        init_db(db_path)
+                        _record("Database", "ok", "initialized (auto-fixed)")
+                        db_status = "ok"
+                        db_msg = "auto-fixed"
+                    except Exception as e:
+                        _record("Database", "fail", f"auto-init failed: {e}")
+        except Exception:
+            _record("Database", "warn", "skipped (not in a git repo)")
 
-    # 6. Git hook
-    console.print()
-    console.print("[bold]5. Git Hook[/bold]")
-    try:
-        root = repo or find_git_root()
-        if is_hook_installed(root):
-            _ok("Post-commit hook installed")
+        # 6. Git hook
+        try:
+            root = repo or find_git_root()
+            if is_hook_installed(root):
+                _record("Hook", "ok", "post-commit hook installed")
+            else:
+                _record("Hook", "warn", "post-commit hook not installed")
+                if fix:
+                    try:
+                        install_hook(root)
+                        _record("Hook", "ok", "installed (auto-fixed)")
+                    except Exception as e:
+                        _record("Hook", "fail", f"auto-install failed: {e}")
+        except Exception:
+            _record("Hook", "warn", "skipped (not in a git repo)")
+
+        # 7. Core dependencies
+        deps = [
+            ("typer", "CLI framework"),
+            ("rich", "Terminal UI"),
+            ("gitpython", "Git integration"),
+            ("fastapi", "REST API"),
+            ("uvicorn", "ASGI server"),
+            ("pydantic", "Data validation"),
+            ("pyjwt", "JWT auth"),
+            ("bcrypt", "Password hashing"),
+        ]
+        for mod_name, desc in deps:
+            try:
+                m = __import__(mod_name)
+                ver = getattr(m, "__version__", "?")
+                _record("Dependencies", "ok", f"{mod_name} {ver} — {desc}")
+            except ImportError:
+                _record("Dependencies", "fail", f"{mod_name} not installed — {desc}")
+
+        # 8. License & Plan
+        license_path = Path.home() / ".codedna" / "license.json"
+        if license_path.exists():
+            try:
+                import json
+                with open(license_path) as f:
+                    lic = json.load(f)
+                plan = lic.get("plan", "free")
+                _record("License", "ok", f"plan = {plan.upper()}")
+            except Exception as e:
+                _record("License", "warn", f"file unreadable: {e}")
         else:
-            _warn("Post-commit hook not installed (run `codedna init`)")
-            warnings.append("no_hook")
-            if fix:
-                try:
-                    install_hook(root)
-                    _ok("Hook installed")
-                except Exception as e:
-                    _fail(f"Could not install hook: {e}")
-                    issues.append("hook_install_failed")
-    except Exception:
-        _warn("Not in a git repo — hook check skipped")
+            _record("License", "warn", f"no license at {license_path} (FREE plan)")
 
-    # 7. Dependencies
-    console.print()
-    console.print("[bold]6. Core Dependencies[/bold]")
-    deps = [
-        ("typer", "CLI framework"),
-        ("rich", "Terminal UI"),
-        ("gitpython", "Git integration"),
-        ("fastapi", "REST API"),
-        ("uvicorn", "ASGI server"),
-        ("pydantic", "Data validation"),
-        ("pyjwt", "JWT auth"),
-        ("bcrypt", "Password hashing"),
-    ]
-    for mod_name, desc in deps:
+        # 9. Network
         try:
-            m = __import__(mod_name)
-            ver = getattr(m, "__version__", "?")
-            _ok(f"{mod_name} {ver} ({desc})")
-        except ImportError:
-            _fail(f"{mod_name} — not installed ({desc})")
-            issues.append(f"missing:{mod_name}")
-
-    # 8. License / plan
-    console.print()
-    console.print("[bold]7. License & Plan[/bold]")
-    license_path = Path.home() / ".codedna" / "license.json"
-    if license_path.exists():
-        try:
-            import json
-            with open(license_path) as f:
-                lic = json.load(f)
-            plan = lic.get("plan", "free")
-            _ok(f"Active plan: {plan.upper()}")
+            import urllib.request
+            urllib.request.urlopen("https://pypi.org/pypi/codedna/json", timeout=5)
+            _record("Network", "ok", "PyPI reachable")
         except Exception as e:
-            _warn(f"License file unreadable: {e}")
-            warnings.append("license_unreadable")
+            _record("Network", "warn", f"PyPI unreachable: {type(e).__name__}")
+
+    # ─── Render results as a beautiful table ────────────────────────────
+    status_emoji = {"ok": "[green]✓[/green]", "warn": "[yellow]⚠[/yellow]", "fail": "[red]✗[/red]", "skip": "[dim]–[/dim]"}
+
+    table = Table(
+        border_style="dim",
+        show_lines=True,
+        header_style="bold cyan",
+        title="[bold]Health Check Results[/bold]",
+        title_style="bold white",
+    )
+    table.add_column("Category", style="bold white", min_width=14)
+    table.add_column("Status", justify="center", min_width=7)
+    table.add_column("Details", style="white")
+
+    current_cat = None
+    for cat, status, msg in checks:
+        emoji = status_emoji.get(status, "[dim]?[/dim]")
+        table.add_row(cat, emoji, msg)
+        current_cat = cat
+
+    console.print(table)
+    console.print()
+
+    # ─── Summary panel ──────────────────────────────────────────────────
+    n_ok = sum(1 for _, s, _ in checks if s == "ok")
+    n_warn = sum(1 for _, s, _ in checks if s == "warn")
+    n_fail = sum(1 for _, s, _ in checks if s == "fail")
+    total = len(checks)
+
+    if n_fail == 0 and n_warn == 0:
+        border = "green"
+        title = "[bold green]✓ All checks passed — system healthy[/bold green]"
+        body = f"[green]{n_ok}/{total} checks passed. CodeDNA is ready to use.[/green]\n\n[dim]Run [bold]codedna scan[/bold] in a git repo to get started.[/dim]"
+    elif n_fail == 0:
+        border = "yellow"
+        title = f"[bold yellow]⚠ {n_warn} warning(s) — system functional with caveats[/bold yellow]"
+        body = f"[yellow]{n_ok}/{total} checks passed, {n_warn} warning(s).[/yellow]\n\n[dim]Run [bold]codedna doctor --fix[/bold] to attempt auto-fixes.[/dim]"
     else:
-        _warn(f"No license at {license_path} (running on FREE plan)")
+        border = "red"
+        title = f"[bold red]✗ {n_fail} critical issue(s) — fix required[/bold red]"
+        body = f"[red]{n_fail} critical, {n_warn} warning, {n_ok} passed (out of {total}).[/red]\n\n[dim]Re-run [bold]codedna doctor --fix[/bold] or install missing dependencies.[/dim]"
+
+    console.print(
+        Panel(
+            body,
+            title=title,
+            border_style=border,
+            padding=(1, 2),
+        )
+    )
+
+    if n_fail > 0:
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# codedna update (self-upgrade from PyPI)
+# ---------------------------------------------------------------------------
+@app.command()
+def update(
+    check_only: bool = typer.Option(False, "--check", "-c", help="Only check for updates, do not install"),
+    target: Optional[str] = typer.Option(None, "--target", "-t", help="Install a specific version (e.g. 0.3.2)"),
+) -> None:
+    """Check for updates and upgrade CodeDNA to the latest PyPI release."""
+    import json
+    import urllib.request
+    import urllib.error
 
-    # 9. Network
+    console.print(Panel.fit("🧬 CodeDNA — Update Check", style="bold cyan"))
     console.print()
-    console.print("[bold]8. Network[/bold]")
+
+    # 1. Get current version
+    import codedna
+    current = codedna.__version__
+    console.print(f"  Current version: [bold]{current}[/bold]")
+
+    # 2. Fetch latest version from PyPI
     try:
-        import urllib.request
-        urllib.request.urlopen("https://pypi.org/pypi/codedna/json", timeout=5)
-        _ok("PyPI reachable")
+        req = urllib.request.Request(
+            "https://pypi.org/pypi/codedna/json",
+            headers={"Accept": "application/json", "User-Agent": "codedna-updater"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as r:
+            data = json.loads(r.read())
     except Exception as e:
-        _warn(f"PyPI unreachable: {type(e).__name__}")
-        warnings.append("no_network")
+        console.print(f"  [red]✗[/red] Could not reach PyPI: {e}")
+        raise typer.Exit(1)
+
+    latest = data["info"]["version"]
+    desired = target or latest
+    console.print(f"  Latest version : [bold]{latest}[/bold]")
+
+    if target:
+        console.print(f"  Target version : [bold]{target}[/bold]")
+
+    # 3. Compare
+    def _parse(v: str) -> tuple[int, ...]:
+        return tuple(int(x) for x in v.split(".") if x.isdigit())
+
+    if _parse(current) >= _parse(desired) and not target:
+        console.print()
+        console.print(f"  [bold green]✓ Already on the latest version.[/bold green]")
+        return
 
-    # Summary
     console.print()
-    console.print("[bold]Summary[/bold]")
-    if not issues:
-        if not warnings:
-            console.print("  [bold green]✓ All checks passed — system healthy.[/bold green]")
-        else:
-            console.print(f"  [bold yellow]![/bold yellow] {len(warnings)} warning(s), 0 critical issue(s)")
-            console.print("  [dim]Run [bold]codedna doctor --fix[/bold] to attempt auto-fixes.[/dim]")
+    if check_only:
+        console.print(f"  [yellow]![/yellow] Update available: {current} → {desired}")
+        console.print(f"  [dim]Run [bold]codedna update[/bold] to install.[/dim]")
+        return
+
+    # 4. Detect installer (uv > pip)
+    import shutil
+    import subprocess
+
+    use_uv = shutil.which("uv") is not None
+    if use_uv:
+        cmd = ["uv", "tool", "install", "--force", f"codedna=={desired}"]
+        label = "uv tool install --force"
     else:
-        console.print(f"  [bold red]✗[/bold red] {len(issues)} critical issue(s), {len(warnings)} warning(s)")
-        for issue in issues:
-            console.print(f"    [red]•[/red] {issue}")
+        cmd = [sys.executable, "-m", "pip", "install", "--upgrade", f"codedna=={desired}"]
+        label = "pip install --upgrade"
+
+    console.print(f"  [cyan]→[/cyan] Running: {label} codedna=={desired}")
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except subprocess.TimeoutExpired:
+        console.print("  [red]✗[/red] Install timed out after 120s")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"  [red]✗[/red] Install failed: {e}")
+        raise typer.Exit(1)
+
+    if result.returncode != 0:
+        console.print(f"  [red]✗[/red] Install returned exit code {result.returncode}")
+        if result.stderr:
+            # Show last 10 lines of stderr
+            for line in result.stderr.strip().split("\n")[-10:]:
+                console.print(f"    [dim]{line}[/dim]")
         raise typer.Exit(1)
 
+    # 5. Verify new version
+    try:
+        # Re-import to get fresh metadata
+        import importlib
+        importlib.reload(codedna)
+        new_ver = codedna.__version__
+    except Exception:
+        new_ver = "?"
+
+    console.print()
+    if new_ver == desired:
+        console.print(f"  [bold green]✓ Updated {current} → {new_ver}[/bold green]")
+    else:
+        console.print(f"  [bold green]✓ Update complete.[/bold green] Installed {desired}; current process shows {new_ver}.")
+        console.print(f"  [dim]Restart your shell to pick up the new binary.[/dim]")
+
 
 # ---------------------------------------------------------------------------
 # Helper functions

{codedna-0.3.2 → codedna-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codedna"
-version = "0.3.2"
+version = "0.3.4"
 description = "AI Code Transparency Tool - detect AI-written code and measure developer understanding"
 readme = "README.md"
 requires-python = ">=3.10"