codedna 0.5.0__tar.gz → 0.5.2__tar.gz

{codedna-0.5.0 → codedna-0.5.2}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.5.2] - 2026-06-24 - "SECURITY CHECK"
+
+### Added
+- `codedna security-check` command - Pre-release security scanner
+  - Personal machine path detection (e.g. `/Users/yourname/`, `/home/user/`)
+  - Tracked secret detection (`.npmrc`, `.env*` in git)
+  - Secret pattern detection (npm, GitHub PAT, OpenAI, Anthropic, PyPI, generic API keys)
+  - `.gitignore` rule verification (.env, .npmrc, node_modules, __pycache__)
+  - Options: `--path` (custom root), `--strict` (exit on warnings)
+  - Output: legacy CLI aesthetic (4 categories, emoji markers, summary panel)
+  - Use case: run BEFORE `uv publish` or `git push` to catch leaks
+  - Critical response: exit 1 on personal paths, tracked secrets, or missing .env rules
+  - Detected the recent NatureCo CLI v5.7.0 issue (sasuke-notes paths + tracked .npmrc)
+
+## [0.5.1] - 2026-06-24 — "Doctor English"
+
+### 🔄 Changed
+- **`codedna doctor`** — translated all messages back to English
+  - Old (0.5.0): "Sistem sağlık kontrolü", "Python Ortamı", "Veritabanı", "Lisans", "Ağ Bağlantısı"
+  - New: "System health check", "Python Environment", "Database", "License & Plan", "Network"
+  - Style preserved: `[bold]─── Category ───[/bold]` headers, emoji markers, summary panel
+- Matches the project's "English-first" policy (README.md, CLI output, docstrings)
+
 ## [0.5.0] - 2026-06-24 — "Phase 8: Demo Mode + VS Code Marketplace"
 
 ### ✨ Added — Demo Mode (Part A)

{codedna-0.5.0 → codedna-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → codedna-0.5.2}/codedna/__init__.py

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

{codedna-0.5.0 → codedna-0.5.2}/codedna/cli.py

@@ -1713,7 +1713,7 @@ def doctor(
     from collections import Counter
 
     console.print()
-    console.print("[bold cyan]🧬 CodeDNA[/bold cyan] — Sistem sağlık kontrolü çalışıyor...\n")
+    console.print("[bold cyan]🧬 CodeDNA[/bold cyan] — System health check running...\n")
 
     issues: list[str] = []
     warnings: list[str] = []
@@ -1727,43 +1727,43 @@ def doctor(
     def _fail(msg: str) -> None:
         console.print(f"  [red]✗[/red] {msg}")
 
-    with console.status("[dim]Testler çalıştırılıyor...[/dim]"):
+    with console.status("[dim]Running tests...[/dim]"):
         # ── 1. Python Environment ──────────────────────────────────────
-        console.print("[bold]─── Python Ortamı ───[/bold]")
+        console.print("[bold]─── 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 gerekli)")
+            _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+ gerekli")
+            _fail(f"Python {py_ver.major}.{py_ver.minor}.{py_ver.micro} — 3.10+ required")
             issues.append("python_version")
 
         try:
             import codedna
             _ok(f"CodeDNA [bold]v{codedna.__version__}[/bold] — {Path(codedna.__file__).parent}")
         except Exception as e:
-            _fail(f"CodeDNA import hatası: {e}")
+            _fail(f"CodeDNA import failed: {e}")
             issues.append("codedna_import")
         console.print()
 
         # ── 2. Git Integration ─────────────────────────────────────────
-        console.print("[bold]─── Git Entegrasyonu ───[/bold]")
+        console.print("[bold]─── Git Integration ───[/bold]")
         try:
             result = subprocess.run(["git", "--version"], capture_output=True, text=True, timeout=5)
             if result.returncode == 0:
                 _ok(f"Git: {result.stdout.strip()}")
             else:
-                _fail("Git komutu hata döndü")
+                _fail("Git command returned non-zero")
                 issues.append("git")
         except FileNotFoundError:
-            _fail("Git PATH'te bulunamadı")
+            _fail("Git not found on PATH")
             issues.append("git")
         except Exception as e:
-            _warn(f"Git kontrolü başarısız: {e}")
+            _warn(f"Git check failed: {e}")
             warnings.append("git_check")
         console.print()
 
         # ── 3. Tree-sitter Parsers ─────────────────────────────────────
-        console.print("[bold]─── Tree-sitter Parser'ları ───[/bold]")
+        console.print("[bold]─── Tree-sitter Parsers ───[/bold]")
         parsers = [
             ("tree_sitter", "tree-sitter"),
             ("tree_sitter_python", "tree-sitter-python"),
@@ -1775,30 +1775,30 @@ def doctor(
                 __import__(mod_name)
                 _ok(pkg_name)
             except ImportError:
-                _fail(f"{pkg_name} — yüklü değil")
+                _fail(f"{pkg_name} — not installed")
                 issues.append(f"missing:{pkg_name}")
         console.print()
 
         # ── 4. Local Database ──────────────────────────────────────────
-        console.print("[bold]─── Yerel Veritabanı ───[/bold]")
+        console.print("[bold]─── 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"Veritabanı: {db_path} ({size_kb:.1f} KB)")
+                _ok(f"Database: {db_path} ({size_kb:.1f} KB)")
             else:
-                _warn(f"Veritabanı yok: {db_path} (oluşturmak için [cyan]codedna init[/cyan])")
+                _warn(f"No database at {db_path} (run [cyan]codedna init[/cyan] to create)")
                 warnings.append("no_db")
                 if fix:
                     try:
                         init_db(db_path)
-                        _ok("Veritabanı oluşturuldu (otomatik düzeltildi)")
+                        _ok("Database created (auto-fixed)")
                     except Exception as e:
-                        _fail(f"Veritabanı oluşturulamadı: {e}")
+                        _fail(f"Database creation failed: {e}")
                         issues.append("db_init_failed")
         except Exception:
-            _warn("Git repo'sunda değilsiniz — veritabanı kontrolü atlandı")
+            _warn("Not in a git repo — database check skipped")
         console.print()
 
         # ── 5. Git Hook ────────────────────────────────────────────────
@@ -1806,32 +1806,32 @@ def doctor(
         try:
             root = repo or find_git_root()
             if is_hook_installed(root):
-                _ok("Post-commit hook kurulu")
+                _ok("Post-commit hook installed")
             else:
-                _warn(f"Post-commit hook kurulu değil ([cyan]codedna init[/cyan] ile kur)")
+                _warn(f"Post-commit hook not installed (run [cyan]codedna init[/cyan])")
                 warnings.append("no_hook")
                 if fix:
                     try:
                         install_hook(root)
-                        _ok("Hook kuruldu (otomatik düzeltildi)")
+                        _ok("Hook installed (auto-fixed)")
                     except Exception as e:
-                        _fail(f"Hook kurulamadı: {e}")
+                        _fail(f"Hook install failed: {e}")
                         issues.append("hook_install_failed")
         except Exception:
-            _warn("Git repo'sunda değilsiniz — hook kontrolü atlandı")
+            _warn("Not in a git repo — hook check skipped")
         console.print()
 
         # ── 6. Core Dependencies ───────────────────────────────────────
-        console.print("[bold]─── Temel Bağımlılıklar ───[/bold]")
+        console.print("[bold]─── Core Dependencies ───[/bold]")
         deps = [
             ("typer", "CLI framework"),
             ("rich", "Terminal UI"),
-            ("gitpython", "Git entegrasyonu"),
+            ("gitpython", "Git integration"),
             ("fastapi", "REST API"),
             ("uvicorn", "ASGI server"),
-            ("pydantic", "Veri doğrulama"),
+            ("pydantic", "Data validation"),
             ("pyjwt", "JWT auth"),
-            ("bcrypt", "Şifre hashleme"),
+            ("bcrypt", "Password hashing"),
         ]
         for mod_name, desc in deps:
             try:
@@ -1839,12 +1839,12 @@ def doctor(
                 ver = getattr(m, "__version__", "?")
                 _ok(f"{mod_name} [dim]{ver}[/dim] — {desc}")
             except ImportError:
-                _fail(f"{mod_name} — yüklü değil ({desc})")
+                _fail(f"{mod_name} — not installed ({desc})")
                 issues.append(f"missing:{mod_name}")
         console.print()
 
         # ── 7. License & Plan ──────────────────────────────────────────
-        console.print("[bold]─── Lisans & Plan ───[/bold]")
+        console.print("[bold]─── License & Plan ───[/bold]")
         license_path = Path.home() / ".codedna" / "license.json"
         if license_path.exists():
             try:
@@ -1852,26 +1852,26 @@ def doctor(
                 with open(license_path) as f:
                     lic = _json.load(f)
                 plan = lic.get("plan", "free")
-                _ok(f"Aktif plan: [bold cyan]{plan.upper()}[/bold cyan]")
+                _ok(f"Active plan: [bold cyan]{plan.upper()}[/bold cyan]")
             except Exception as e:
-                _warn(f"Lisans dosyası okunamadı: {e}")
+                _warn(f"License file unreadable: {e}")
                 warnings.append("license_unreadable")
         else:
-            _warn(f"Lisans yok: {license_path} (FREE planda)")
+            _warn(f"No license at {license_path} (running FREE plan)")
         console.print()
 
         # ── 8. Network ─────────────────────────────────────────────────
-        console.print("[bold]─── Ağ Bağlantısı ───[/bold]")
+        console.print("[bold]─── Network ───[/bold]")
         try:
             import urllib.request
             urllib.request.urlopen("https://pypi.org/pypi/codedna/json", timeout=5)
-            _ok("PyPI erişilebilir")
+            _ok("PyPI reachable")
         except Exception as e:
-            _warn(f"PyPI'ya erişilemedi: {type(e).__name__}")
+            _warn(f"PyPI unreachable: {type(e).__name__}")
             warnings.append("no_network")
         console.print()
 
-    # ── Özet ────────────────────────────────────────────────────────
+    # ── Summary ────────────────────────────────────────────────────────
     n_ok = 0
     for cat in [issues, warnings]:
         pass
@@ -1879,40 +1879,40 @@ def doctor(
     # We counted "ok" via the _ok helper which printed — let's track via passed back.
     # Simpler: infer from known list sizes.
     # We'll fix the count by reconstructing from a counter:
-    console.print("[bold]─── Özet ───[/bold]")
+    console.print("[bold]─── Summary ───[/bold]")
     n_total_fail = len(issues)
     n_total_warn = len(warnings)
     n_total_ok = 19 - n_total_fail - n_total_warn  # 9 kategori toplam 19 check (8 deps + 4 parsers + 1+1+1+1+1+1+1+1+1)
 
     if n_total_fail == 0 and n_total_warn == 0:
-        console.print(f"  [bold green]✓ Tüm testler başarılı — sistem sağlıklı.[/bold green]")
+        console.print(f"  [bold green]✓ All checks passed — system healthy.[/bold green]")
         bilgi = (
-            f"[bold green]CodeDNA sağlık durumu: MÜKEMMEL[/bold green]\n"
-            f"[dim]Tüm {n_total_ok} kontrol geçti. CodeDNA kullanıma hazır.[/dim]\n\n"
-            f"[dim]• Repo taramak için:[/dim] [cyan]codedna scan[/cyan]\n"
-            f"[dim]• Son commit için:[/dim]    [cyan]codedna status[/cyan]\n"
-            f"[dim]• Setup için:[/dim]        [cyan]codedna setup[/cyan]"
+            f"[bold green]CodeDNA health: EXCELLENT[/bold green]\n"
+            f"[dim]All {n_total_ok} checks passed. CodeDNA is ready to use.[/dim]\n\n"
+            f"[dim]• Scan a repo:[/dim]   [cyan]codedna scan[/cyan]\n"
+            f"[dim]• Last commit:[/dim]   [cyan]codedna status[/cyan]\n"
+            f"[dim]• Configure:[/dim]    [cyan]codedna setup[/cyan]"
         )
         console.print()
         console.print(Panel(bilgi, border_style="green", padding=(1, 2)))
     elif n_total_fail == 0:
-        console.print(f"  [bold yellow]⚠  {n_total_warn} uyarı var, kritik sorun yok.[/bold yellow]")
+        console.print(f"  [bold yellow]⚠  {n_total_warn} warning(s), no critical issues.[/bold yellow]")
         bilgi = (
-            f"[bold yellow]CodeDNA sağlık durumu: UYARILAR VAR[/bold yellow]\n"
-            f"[dim]{n_total_warn} uyarı, 0 kritik. Sistem çalışıyor ama dikkat gerekli.[/dim]\n\n"
-            f"[dim]Otomatik düzeltme için:[/dim] [cyan]codedna doctor --fix[/cyan]"
+            f"[bold yellow]CodeDNA health: WARNINGS[/bold yellow]\n"
+            f"[dim]{n_total_warn} warning(s), 0 critical. System works but review needed.[/dim]\n\n"
+            f"[dim]Auto-fix:[/dim] [cyan]codedna doctor --fix[/cyan]"
         )
         console.print()
         console.print(Panel(bilgi, border_style="yellow", padding=(1, 2)))
     else:
-        console.print(f"  [bold red]✗  {n_total_fail} kritik sorun, {n_total_warn} uyarı.[/bold red]")
+        console.print(f"  [bold red]✗  {n_total_fail} critical issue(s), {n_total_warn} warning(s).[/bold red]")
         for issue in issues:
             console.print(f"    [red]•[/red] {issue}")
         bilgi = (
-            f"[bold red]CodeDNA sağlık durumu: KRİTİK SORUNLAR[/bold red]\n"
-            f"[red]{n_total_fail} kritik, {n_total_warn} uyarı, {n_total_ok} geçti.[/red]\n\n"
-            f"[dim]Eksik paketleri yükleyin veya şunu çalıştırın:[/dim]\n"
-            f"[cyan]pip install -U codedna[/cyan] [dim]veya[/dim] [cyan]uv tool install --force 'codedna=={__version__}'[/cyan]"
+            f"[bold red]CodeDNA health: CRITICAL ISSUES[/bold red]\n"
+            f"[red]{n_total_fail} critical, {n_total_warn} warning(s), {n_total_ok} passed.[/red]\n\n"
+            f"[dim]Install missing packages or run:[/dim]\n"
+            f"[cyan]pip install -U codedna[/cyan] [dim]or[/dim] [cyan]uv tool install --force 'codedna=={__version__}'[/cyan]"
         )
         console.print()
         console.print(Panel(bilgi, border_style="red", padding=(1, 2)))
@@ -2146,6 +2146,208 @@ def demo(
     console.print()
 
 
+# ---------------------------------------------------------------------------
+# codedna security-check (pre-release secret & personal path scanner)
+# ---------------------------------------------------------------------------
+@app.command(name="security-check")
+def security_check(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project root to scan (defaults to cwd)"),
+    strict: bool = typer.Option(False, "--strict", help="Exit 1 on any warning"),
+) -> None:
+    """Scan the project for personal paths, secrets, and missing .gitignore rules.
+
+    Run this BEFORE publishing or pushing to GitHub. Catches:
+    - Personal machine paths in code/README (e.g. /Users/yourname/...)
+    - Tracked secrets (.npmrc, .env*, api_key, token patterns)
+    - Missing .gitignore rules for sensitive files
+    """
+    import subprocess
+    from codedna.git_hook import find_git_root
+    import re
+
+    root = path or find_git_root() or Path.cwd()
+    if not root.exists():
+        console.print(f"  [red]✗[/red] Path not found: {root}")
+        raise typer.Exit(1)
+
+    console.print()
+    console.print(f"[bold cyan]🧬 CodeDNA[/bold cyan] — Security check: [dim]{root}[/dim]\n")
+
+    issues: list[tuple[str, str, str]] = []  # (severity, category, message)
+    warnings: list[tuple[str, str, str]] = []
+
+    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}")
+
+    # ── 1. Personal machine paths ─────────────────────────────────────
+    console.print("[bold]─── 1. Personal Path Scan ───[/bold]")
+    personal_pattern = re.compile(r"/Users/[\w.-]+/|\/home\/[\w.-]+/|C:\\Users\\[\w.-]+\\")
+    found_personal: list[str] = []
+
+    # Scan README, source, and markdown files
+    scan_extensions = {".md", ".py", ".js", ".ts", ".json", ".sh", ".yml", ".yaml", ".toml"}
+    file_count = 0
+    for ext in scan_extensions:
+        for f in root.rglob(f"*{ext}"):
+            # Skip ignored dirs
+            if any(p in f.parts for p in [".git", "node_modules", "dist", "build", ".venv", "venv", "__pycache__"]):
+                continue
+            try:
+                content = f.read_text(errors="ignore")
+            except Exception:
+                continue
+            file_count += 1
+            matches = personal_pattern.findall(content)
+            if matches:
+                # Show unique paths
+                unique = set(matches)
+                for m in unique:
+                    if m not in found_personal:
+                        found_personal.append(m)
+                        rel = f.relative_to(root) if f.is_relative_to(root) else f
+                        _fail(f"Found: {m}  in  {rel}")
+                        issues.append(("fail", "personal-path", f"{m} in {rel}"))
+
+    if not found_personal:
+        _ok(f"No personal paths found ({file_count} files scanned)")
+    console.print()
+
+    # ── 2. Tracked secrets ────────────────────────────────────────────
+    console.print("[bold]─── 2. Tracked Secret Scan ───[/bold]")
+
+    # Check if .npmrc, .env*, .git/config is tracked
+    secret_files = [".npmrc", ".env", ".env.local", ".env.test", ".env.production"]
+    for sf in secret_files:
+        f = root / sf
+        if f.exists():
+            # Check if tracked
+            r = subprocess.run(
+                ["git", "ls-files", "--error-unmatch", str(f.relative_to(root))],
+                cwd=str(root), capture_output=True, text=True
+            )
+            if r.returncode == 0:
+                _fail(f"{sf} is tracked in git (contains secrets!)")
+                issues.append(("fail", "tracked-secret", f"{sf} tracked"))
+            else:
+                _ok(f"{sf} exists locally but is NOT tracked (safe)")
+        else:
+            _ok(f"{sf} not present")
+    console.print()
+
+    # ── 3. Secret patterns in tracked files ──────────────────────────
+    console.print("[bold]─── 3. Secret Pattern Scan ───[/bold]")
+    secret_patterns = {
+        "npm token": re.compile(r"npm_[A-Za-z0-9]{20,}"),
+        "GitHub PAT": re.compile(r"ghp_[A-Za-z0-9]{20,}"),
+        "OpenAI key": re.compile(r"sk-[A-Za-z0-9]{20,}"),
+        "Anthropic key": re.compile(r"sk-ant-[A-Za-z0-9]{20,}"),
+        "PyPI token": re.compile(r"pypi-[A-Za-z0-9]{20,}"),
+        "Generic API key": re.compile(r"(?i)(api[_-]?key|token|secret)\s*[:=]\s*['\"][A-Za-z0-9_-]{16,}['\"]"),
+    }
+
+    found_secrets: list[tuple[str, str, str]] = []
+    for ext in [".py", ".js", ".ts", ".json", ".sh", ".md"]:
+        for f in root.rglob(f"*{ext}"):
+            if any(p in f.parts for p in [".git", "node_modules", "dist", "build", ".venv", "venv", "__pycache__", ".pytest_cache"]):
+                continue
+            try:
+                content = f.read_text(errors="ignore")
+            except Exception:
+                continue
+            for name, pattern in secret_patterns.items():
+                if pattern.search(content):
+                    rel = f.relative_to(root) if f.is_relative_to(root) else f
+                    # Skip if it's in a docstring example or test fixture
+                    if "example" in str(rel).lower() or "test" in str(rel).lower() or "fixture" in str(rel).lower():
+                        continue
+                    # Skip obvious placeholders
+                    if any(ph in content.lower() for ph in ["placeholder", "your_api_key", "xxx", "00000"]):
+                        continue
+                    found_secrets.append((name, str(rel), pattern.pattern[:30]))
+                    _fail(f"{name} pattern in {rel}")
+                    issues.append(("fail", "secret-pattern", f"{name} in {rel}"))
+
+    if not found_secrets:
+        _ok("No secret patterns found")
+    console.print()
+
+    # ── 4. .gitignore verification ────────────────────────────────────
+    console.print("[bold]─── 4. .gitignore Verification ───[/bold]")
+    gitignore = root / ".gitignore"
+    if not gitignore.exists():
+        _fail(".gitignore not found")
+        issues.append(("fail", "no-gitignore", "no .gitignore"))
+    else:
+        content = gitignore.read_text()
+        # Check critical rules
+        required_rules = {
+            ".env": False,
+            ".env.": False,
+            ".npmrc": False,
+            "node_modules": False,
+            "__pycache__": False,
+        }
+        for line in content.split("\n"):
+            line = line.strip()
+            for rule in required_rules:
+                if rule == line or (rule.endswith(".") and rule in line):
+                    required_rules[rule] = True
+
+        for rule, present in required_rules.items():
+            if present:
+                _ok(f".gitignore includes {rule} (or pattern)")
+            else:
+                _warn(f".gitignore missing {rule} rule")
+                warnings.append(("warn", "gitignore-missing", f"missing {rule}"))
+    console.print()
+
+    # ── Summary ───────────────────────────────────────────────────────
+    n_fail = len(issues)
+    n_warn = len(warnings)
+    console.print("[bold]─── Summary ───[/bold]")
+
+    if n_fail == 0 and n_warn == 0:
+        console.print("  [bold green]✓ All security checks passed — safe to publish.[/bold green]")
+        bilgi = (
+            f"[bold green]CodeDNA security: CLEAN[/bold green]\n\n"
+            f"[dim]All checks passed. No personal paths, no tracked secrets, no secret patterns.[/dim]\n\n"
+            f"[dim]Safe to run:[/dim] [cyan]npm publish[/cyan] [dim]or[/dim] [cyan]uv publish[/cyan]"
+        )
+        border = "green"
+    elif n_fail == 0:
+        console.print(f"  [bold yellow]⚠  {n_warn} warning(s), 0 critical issues.[/bold yellow]")
+        bilgi = (
+            f"[bold yellow]CodeDNA security: WARNINGS[/bold yellow]\n\n"
+            f"[dim]{n_warn} warning(s) to review, but no critical issues blocking publish.[/dim]\n\n"
+            f"[dim]Re-run after fixes:[/dim] [cyan]codedna security-check[/cyan]"
+        )
+        border = "yellow"
+    else:
+        console.print(f"  [bold red]✗  {n_fail} critical issue(s), {n_warn} warning(s).[/bold red]")
+        for sev, cat, msg in issues:
+            console.print(f"    [red]•[/red] [{cat}] {msg}")
+        bilgi = (
+            f"[bold red]CodeDNA security: BLOCKED[/bold red]\n\n"
+            f"[red]{n_fail} critical issue(s) must be fixed before publishing.[/red]\n\n"
+            f"[dim]Fix issues, add to .gitignore, then re-run:[/dim]\n"
+            f"[cyan]codedna security-check[/cyan]"
+        )
+        border = "red"
+
+    console.print()
+    console.print(Panel(bilgi, border_style=border, padding=(1, 2)))
+    console.print()
+
+    if n_fail > 0 or (strict and n_warn > 0):
+        raise typer.Exit(1)
+
+
 # ---------------------------------------------------------------------------
 # codedna setup (interactive AI analysis configuration wizard)
 # ---------------------------------------------------------------------------

{codedna-0.5.0 → codedna-0.5.2}/pyproject.toml

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