codedna 0.9.1__tar.gz → 0.9.3__tar.gz

{codedna-0.9.1 → codedna-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedna
-Version: 0.9.1
+Version: 0.9.3
 Summary: AI Code Transparency Tool — detect AI-written code, analyze commit quality, track understanding debt, sprint health, bus factor, and more
 Project-URL: Homepage, https://codedna.dev
 Project-URL: Repository, https://github.com/natureco-official/codedna
@@ -44,10 +44,13 @@ Requires-Dist: uvicorn[standard]>=0.49.0
 Provides-Extra: dashboard
 Requires-Dist: next-cmd>=0.5.0; extra == 'dashboard'
 Provides-Extra: dev
-Requires-Dist: black>=24.0.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
-Requires-Dist: pytest>=8.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: black>=26.5.1; extra == 'dev'
+Requires-Dist: pytest-cov>=7.1.0; extra == 'dev'
+Requires-Dist: pytest>=9.1.1; extra == 'dev'
+Requires-Dist: ruff>=0.15.19; extra == 'dev'
+Provides-Extra: nl
+Requires-Dist: huggingface-hub; extra == 'nl'
+Requires-Dist: pyarrow<18,>=14; extra == 'nl'
 Description-Content-Type: text/markdown
 
 <div align="center">

{codedna-0.9.1 → codedna-0.9.3}/codedna/__init__.py

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

{codedna-0.9.1 → codedna-0.9.3}/codedna/analyzer.py

@@ -51,11 +51,9 @@ try:
     import tree_sitter_typescript as tstypescript
     _TS_LANG = tstypescript.language_typescript()
     _TSX_LANG = tstypescript.language_tsx()
-    _TS_AVAILABLE = True
 except Exception:
     _TS_LANG = tsjavascript.language()
     _TSX_LANG = tsjavascript.language()
-    _TS_AVAILABLE = False
 
 # Supported language map
 LANGUAGE_MAP: dict[str, tuple] = {

{codedna-0.9.1 → codedna-0.9.3}/codedna/api.py

@@ -69,7 +69,7 @@ app = FastAPI(
 # CORS — fully open for dashboard or external tools
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["http://localhost:3000"],
     allow_methods=["*"],
     allow_headers=["*"],
 )

{codedna-0.9.1 → codedna-0.9.3}/codedna/cli.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -131,6 +132,52 @@ def init(
     console.print(Panel(info, border_style="green", padding=(1, 2)))
 
 
+# ---------------------------------------------------------------------------
+# codedna account  (NatureCo SSO — shared with the NatureCo CLI & terminal)
+# ---------------------------------------------------------------------------
+@app.command()
+def account(
+    action: str = typer.Argument("whoami", help="login | logout | whoami"),
+) -> None:
+    """Sign in with your NatureCo account (single account across the ecosystem)."""
+    from codedna import natureco_account as nc
+
+    if action == "whoami":
+        me = nc.whoami()
+        if me:
+            console.print(f"[green]✓[/green] Signed in as [bold]{me.get('email')}[/bold]")
+        else:
+            console.print("[yellow]Not signed in.[/yellow] Run [bold cyan]codedna account login[/bold cyan]")
+        return
+
+    if action == "logout":
+        nc.logout()
+        console.print("[green]✓[/green] Signed out.")
+        return
+
+    if action == "login":
+        email = typer.prompt("NatureCo email").strip()
+        use_pw = typer.confirm("Sign in with a password? (No = email a code/login link)", default=False)
+        try:
+            if use_pw:
+                password = typer.prompt("Password", hide_input=True)
+                res = nc.login_with_password(email, password)
+            else:
+                nc.send_otp(email)
+                console.print("[dim]Check your email — paste the 6-digit code or the full login link.[/dim]")
+                value = typer.prompt("Code or login link").strip()
+                res = nc.verify_link(value) if "://" in value else nc.verify_otp(email, value)
+            who = (res.get("user") or {}).get("email") or email
+            console.print(f"[green]✓ Signed in as[/green] [bold]{who}[/bold]")
+        except Exception as e:  # noqa: BLE001
+            console.print(f"[red]✗ Sign-in failed:[/red] {e}")
+            raise typer.Exit(1) from e
+        return
+
+    console.print(f"[red]Unknown action:[/red] {action}  [dim](use: login | logout | whoami)[/dim]")
+    raise typer.Exit(1)
+
+
 # ---------------------------------------------------------------------------
 # codedna scan
 # ---------------------------------------------------------------------------
@@ -139,17 +186,29 @@ def scan(
     repo: Optional[Path] = typer.Option(None, "--repo", "-r", help="Git repo directory"),
     max_files: int = typer.Option(200, "--max", "-m", help="Maximum number of files to scan"),
     min_risk: float = typer.Option(0.0, "--min-risk", help="Minimum AI probability filter (0.0-1.0)"),
+    json_out: bool = typer.Option(False, "--json", help="Output machine-readable JSON (for tooling)"),
 ) -> None:
     """Scan current repo and show AI risk report."""
-    console.print()
-    console.print("[bold cyan]🧬 CodeDNA[/bold cyan] — Scanning repo...\n")
+    if not json_out:
+        console.print()
+        console.print("[bold cyan]🧬 CodeDNA[/bold cyan] — Scanning repo...\n")
 
     root = repo or find_git_root() or Path.cwd()
 
-    with console.status("[dim]Analyzing files...[/dim]"):
+    if json_out:
         results = scan_repository(root, max_files=max_files)
+    else:
+        with console.status("[dim]Analyzing files...[/dim]"):
+            results = scan_repository(root, max_files=max_files)
 
     if not results:
+        if json_out:
+            import json as _json
+            print(_json.dumps({
+                "version": __version__, "repo": str(root), "file_count": 0,
+                "avg_ai_probability": 0.0, "max_ai_probability": 0.0, "files": [],
+            }, indent=2))
+            raise typer.Exit(0)
         console.print("[yellow]No supported files found to scan.[/yellow]")
         console.print("[dim]Supported: .py .js .jsx .ts .tsx[/dim]")
         return
@@ -169,6 +228,30 @@ def scan(
     except Exception:
         pass
 
+    # --json: machine-readable output for tooling (e.g. the NatureCo CLI `dna` command)
+    if json_out:
+        import json as _json
+        avg_ai = (sum(s.ai_probability for s in results) / len(results)) if results else 0.0
+        payload = {
+            "version": __version__,
+            "repo": str(root),
+            "file_count": len(results),
+            "avg_ai_probability": round(avg_ai, 4),
+            "max_ai_probability": round(max((s.ai_probability for s in results), default=0.0), 4),
+            "files": [
+                {
+                    "file": s.file_path,
+                    "ai_probability": round(s.ai_probability, 4),
+                    "complexity": s.complexity_label,
+                    "lines": s.total_lines,
+                    "understanding": understanding_scores_map.get(s.file_path),
+                }
+                for s in results
+            ],
+        }
+        print(_json.dumps(payload, indent=2, default=str))
+        raise typer.Exit(0)
+
     # Build table
     table = Table(
         title="",
@@ -499,7 +582,6 @@ def serve(
     repo: Optional[Path] = typer.Option(None, "--repo", "-r", help="Git repo directory"),
 ) -> None:
     """Start the FastAPI REST server."""
-    import os
     import uvicorn
 
     root = repo or find_git_root() or Path.cwd()
@@ -813,7 +895,7 @@ def pr_comment(
     """Post CodeDNA analysis comment to GitHub PR (updates existing comment, no spam)."""
     import os
     from codedna.integrations.github_bot import (
-        format_pr_comment, post_or_update_comment, github_actions_pr_infosi,
+        format_pr_comment, post_or_update_comment, github_actions_pr_bilgisi,
     )
     from codedna.tech_debt import calculate_repo_debt
 
@@ -830,7 +912,7 @@ def pr_comment(
     target_pr = pr
 
     if not target_repo or not target_pr:
-        info = github_actions_pr_infosi()
+        info = github_actions_pr_bilgisi()
         if info:
             auto_repo, auto_pr = info
             target_repo = target_repo or auto_repo
@@ -1130,13 +1212,13 @@ def interview_list(
     table.add_column("Notes", min_width=20)
 
     for o in sessions:
-        score_str = f"{o['skor']:.1f}/5" if o["skor"] is not None else "[dim]—[/dim]"
+        score_str = f"{o['score']:.1f}/5" if o["score"] is not None else "[dim]—[/dim]"
         table.add_row(
             str(o["id"]),
-            o["candidate"] or o.get("aday") or "?",
-            o["start_time"] or o.get("start_date") or "?",
+            o["candidate"] or "?",
+            o["start_time"] or "?",
             score_str,
-            (o["notes"] or o.get("notlar") or "")[:30],
+            (o["notes"] or "")[:30],
         )
 
     console.print()
@@ -1188,7 +1270,7 @@ def bus_factor(
     from codedna.bus_factor import calculate_bus_factor, get_at_risk_files, _LARGE_REPO_THRESHOLD
     from codedna.plan import is_feature_available
 
-        # Plan check
+    # Plan check
     if not is_feature_available("bus_factor"):
         console.print(
             Panel(
@@ -2041,6 +2123,21 @@ def doctor(
     console.print()
 
 
+# ---------------------------------------------------------------------------
+# codedna ask (natural language → command, powered by Needle)
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def ask(
+    query: list[str] = typer.Argument(..., help="What you want to do, in plain language."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show the command without running it."),
+) -> None:
+    """Run a CodeDNA command from a natural-language request (powered by Needle)."""
+    from codedna.nl import route_command
+    route_command(" ".join(query), dry_run=dry_run)
+
+
 # ---------------------------------------------------------------------------
 # codedna update (self-upgrade from PyPI)
 # ---------------------------------------------------------------------------

{codedna-0.9.1 → codedna-0.9.3}/codedna/db.py

@@ -147,6 +147,7 @@ def save_file_score(
     complexity_score: float,
     comment_ratio: float,
     understanding_score: Optional[float] = None,
+    ai_tool_guess: Optional[str] = None,
     db_path: Optional[Path] = None,
 ) -> None:
     """Save a file analysis score."""
@@ -154,10 +155,10 @@ def save_file_score(
         conn.execute(
             """
             INSERT INTO file_scores
-                (commit_hash, file_path, ai_probability, complexity_score, comment_ratio, understanding_score)
-            VALUES (?, ?, ?, ?, ?, ?)
+                (commit_hash, file_path, ai_probability, complexity_score, comment_ratio, understanding_score, ai_tool_guess)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
             """,
-            (commit_hash, file_path, ai_probability, complexity_score, comment_ratio, understanding_score),
+            (commit_hash, file_path, ai_probability, complexity_score, comment_ratio, understanding_score, ai_tool_guess),
         )
 
 
@@ -227,8 +228,13 @@ def get_all_file_understanding_scores(
             FROM file_scores fs
             JOIN commits c ON fs.commit_hash = c.commit_hash
             WHERE fs.understanding_score IS NOT NULL
-            GROUP BY fs.file_path
-            HAVING c.timestamp = MAX(c.timestamp)
+              AND c.timestamp = (
+                  SELECT MAX(c2.timestamp)
+                  FROM file_scores fs2
+                  JOIN commits c2 ON fs2.commit_hash = c2.commit_hash
+                  WHERE fs2.file_path = fs.file_path
+                    AND fs2.understanding_score IS NOT NULL
+              )
             """,
         ).fetchall()
     return {r["file_path"]: float(r["understanding_score"]) for r in rows}

codedna-0.9.3/codedna/natureco_account.py

@@ -0,0 +1,200 @@
+"""NatureCo Account (SSO) — one NatureCo account, ecosystem-wide.
+
+Shares the same session file (``~/.natureco/auth.json``) with the NatureCo CLI
+and Cupertino Terminal, so signing in once works everywhere. Built on the
+natureco.me Supabase Auth REST API. Dependency-free (standard-library urllib);
+the anon key is public (embedded in every client, not a secret).
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+# natureco.me identity project — anon key is PUBLIC (shipped in clients, not secret)
+SUPABASE_URL = os.environ.get("NATURECO_SUPABASE_URL", "https://mxnlehflfkesasclcldy.supabase.co")
+SUPABASE_ANON = os.environ.get(
+    "NATURECO_SUPABASE_ANON",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im14bmxlaGZsZmtlc2FzY2xjbGR5Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzY2NDA5MzEsImV4cCI6MjA5MjIxNjkzMX0.93aPOg6bVmgFaJvsM5jVZwiX2TTuFIyAzhP6BlhBkGU",
+)
+AUTH_BASE = f"{SUPABASE_URL}/auth/v1"
+
+
+class NatureCoAuthError(Exception):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def _auth_file() -> Path:
+    return Path.home() / ".natureco" / "auth.json"
+
+
+def load_session() -> dict | None:
+    try:
+        return json.loads(_auth_file().read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def save_session(session: dict) -> dict:
+    f = _auth_file()
+    f.parent.mkdir(parents=True, exist_ok=True)
+    f.write_text(json.dumps(session, indent=2), encoding="utf-8")
+    try:
+        os.chmod(f, 0o600)
+    except Exception:
+        pass
+    return session
+
+
+def clear_session() -> None:
+    try:
+        _auth_file().unlink()
+    except Exception:
+        pass
+
+
+def _post(path: str, body: dict, access_token: str | None = None) -> dict:
+    headers = {"apikey": SUPABASE_ANON, "Content-Type": "application/json"}
+    if access_token:
+        headers["Authorization"] = f"Bearer {access_token}"
+    req = urllib.request.Request(
+        f"{AUTH_BASE}{path}", data=json.dumps(body).encode(), headers=headers, method="POST"
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return json.loads(r.read().decode())
+    except urllib.error.HTTPError as e:
+        try:
+            data = json.loads(e.read().decode())
+        except Exception:
+            data = {}
+        msg = data.get("error_description") or data.get("msg") or data.get("error") or f"Auth error ({e.code})"
+        raise NatureCoAuthError(msg, e.code) from e
+
+
+def _shape(s: dict) -> dict:
+    expires_at = s.get("expires_at") or (int(time.time()) + s["expires_in"] if s.get("expires_in") else None)
+    user = s.get("user")
+    return {
+        "access_token": s.get("access_token"),
+        "refresh_token": s.get("refresh_token"),
+        "token_type": s.get("token_type", "bearer"),
+        "expires_at": expires_at,
+        "user": {"id": user["id"], "email": user["email"]} if user else None,
+    }
+
+
+def _user_from_jwt(token: str) -> dict | None:
+    """Decode the user out of the access token (no signature check — display only)."""
+    try:
+        part = token.split(".")[1]
+        part += "=" * (-len(part) % 4)
+        p = json.loads(base64.urlsafe_b64decode(part))
+        return {"id": p.get("sub"), "email": p.get("email")}
+    except Exception:
+        return None
+
+
+def login_with_password(email: str, password: str) -> dict:
+    return save_session(_shape(_post("/token?grant_type=password", {"email": email, "password": password})))
+
+
+def send_otp(email: str) -> dict:
+    """Passwordless: send a code / login link to the email (existing account only)."""
+    _post("/otp", {"email": email, "create_user": False})
+    return {"sent": True, "email": email}
+
+
+def verify_otp(email: str, token: str) -> dict:
+    """Verify the OTP code. Depending on the email template the verification type
+    may be 'email' or 'magiclink', so both are attempted."""
+    code = "".join(str(token).split())
+    try:
+        return save_session(_shape(_post("/verify", {"type": "email", "email": email, "token": code})))
+    except NatureCoAuthError as e1:
+        try:
+            return save_session(_shape(_post("/verify", {"type": "magiclink", "email": email, "token": code})))
+        except Exception:
+            raise e1
+
+
+def verify_link(link: str) -> dict:
+    """Sign in from a magic login-link email. Handles both the implicit flow
+    (access_token in the URL fragment) and the token_hash flow."""
+    u = urlparse(link.strip())
+    frag = parse_qs(u.fragment)
+    q = parse_qs(u.query)
+
+    def pick(k: str):
+        return (frag.get(k) or q.get(k) or [None])[0]
+
+    access_token = pick("access_token")
+    if access_token:
+        return save_session(_shape({
+            "access_token": access_token,
+            "refresh_token": pick("refresh_token"),
+            "token_type": pick("token_type") or "bearer",
+            "expires_at": int(pick("expires_at") or 0) or None,
+            "expires_in": int(pick("expires_in") or 0) or None,
+            "user": _user_from_jwt(access_token),
+        }))
+    token_hash = pick("token_hash") or pick("token")
+    typ = pick("type") or "magiclink"
+    if not token_hash:
+        raise NatureCoAuthError("No verification token found in the link")
+    return save_session(_shape(_post("/verify", {"type": typ, "token_hash": token_hash})))
+
+
+def refresh() -> dict:
+    s = load_session()
+    if not s or not s.get("refresh_token"):
+        raise NatureCoAuthError("Not signed in", 401)
+    return save_session(_shape(_post("/token?grant_type=refresh_token", {"refresh_token": s["refresh_token"]})))
+
+
+def get_access_token() -> str | None:
+    s = load_session()
+    if not s:
+        return None
+    if s.get("expires_at") and time.time() > s["expires_at"] - 60:
+        try:
+            s = refresh()
+        except Exception:
+            return None
+    return s.get("access_token") if s else None
+
+
+def whoami() -> dict | None:
+    token = get_access_token()
+    if not token:
+        return None
+    req = urllib.request.Request(
+        f"{AUTH_BASE}/user", headers={"apikey": SUPABASE_ANON, "Authorization": f"Bearer {token}"}
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return json.loads(r.read().decode())
+    except Exception:
+        return None
+
+
+def is_logged_in() -> bool:
+    s = load_session()
+    return bool(s and s.get("access_token"))
+
+
+def current_email() -> str | None:
+    s = load_session()
+    return s.get("user", {}).get("email") if s and s.get("user") else None
+
+
+def logout() -> None:
+    clear_session()

codedna-0.9.3/codedna/nl.py

@@ -0,0 +1,234 @@
+"""codedna/nl.py — Natural language router for CodeDNA, powered by Needle.
+
+Lets a user type a request in plain language and have it translated
+into the matching `codedna` CLI invocation. The model itself is
+multilingual at the input level, so the command works regardless of
+which language the user types in — only the code, comments, and
+output messages are kept in English for consistency with the rest
+of the project.
+
+Usage (standalone):
+    python -m codedna.nl "show me the AI score for my last commit"
+
+Usage (from cli.py):
+    from codedna.nl import route_command
+    route_command(user_query)
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from needle import SimpleAttentionNetwork, load_checkpoint, generate, get_tokenizer
+
+# ---------------------------------------------------------------------------
+# Tool definitions — mirrors codedna_tools.json. Keep these two in sync.
+# ---------------------------------------------------------------------------
+
+TOOLS_PATH = Path(__file__).parent / "nl_tools.json"
+
+
+def _load_tools() -> str:
+    if TOOLS_PATH.exists():
+        return TOOLS_PATH.read_text(encoding="utf-8")
+    raise FileNotFoundError(
+        f"{TOOLS_PATH} not found. Copy codedna_tools.json into codedna/ as nl_tools.json."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Needle model (loaded once, lazily)
+# ---------------------------------------------------------------------------
+
+# Checkpoint paths. The fine-tuned checkpoint (if present) takes priority
+# over the base Hugging Face download. Both are kept under ~/.codedna/needle/
+# so they are shared across projects and never committed by accident.
+_CHECKPOINT_DIR = Path.home() / ".codedna" / "needle"
+_FINETUNED_PATH = _CHECKPOINT_DIR / "needle-finetuned.pkl"
+_CHECKPOINT_PATH = _CHECKPOINT_DIR / "needle.pkl"
+_HF_REPO_ID = "Cactus-Compute/needle"
+_HF_FILENAME = "needle.pkl"
+
+_MODEL = None
+_PARAMS = None
+_TOKENIZER = None
+
+
+def _resolve_checkpoint() -> Path:
+    """Return the best available checkpoint path.
+
+    Priority:
+      1. Fine-tuned checkpoint at ~/.codedna/needle/needle-finetuned.pkl
+      2. Already-downloaded base model at ~/.codedna/needle/needle.pkl
+      3. Auto-downloaded from Hugging Face, cached at (2)
+    """
+    if _FINETUNED_PATH.exists():
+        return _FINETUNED_PATH
+    if _CHECKPOINT_PATH.exists():
+        return _CHECKPOINT_PATH
+
+    try:
+        from huggingface_hub import hf_hub_download
+    except ImportError as exc:
+        raise ImportError(
+            "huggingface_hub is required to auto-download the Needle checkpoint. "
+            "Install it with: pip install codedna[nl]"
+        ) from exc
+
+    print("First run: downloading the Needle model (~53 MB)...", file=sys.stderr)
+    _CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)
+    downloaded_path = hf_hub_download(repo_id=_HF_REPO_ID, filename=_HF_FILENAME)
+
+    # hf_hub_download caches under ~/.cache/huggingface; copy it into our own
+    # checkpoint dir so the path stays stable and predictable for the CLI.
+    import shutil
+    shutil.copyfile(downloaded_path, _CHECKPOINT_PATH)
+    print(f"Needle model cached at {_CHECKPOINT_PATH}", file=sys.stderr)
+    return _CHECKPOINT_PATH
+
+
+def _ensure_model_loaded() -> None:
+    global _MODEL, _PARAMS, _TOKENIZER
+    if _MODEL is not None:
+        return
+    checkpoint_path = _resolve_checkpoint()
+    params, config = load_checkpoint(str(checkpoint_path))
+    _MODEL = SimpleAttentionNetwork(config)
+    _PARAMS = params
+    _TOKENIZER = get_tokenizer()
+
+
+# ---------------------------------------------------------------------------
+# Mapping from tool call -> actual `codedna` CLI argv
+# ---------------------------------------------------------------------------
+
+def _build_argv(name: str, args: dict) -> list[str]:
+    """Translate a Needle tool call into a `codedna ...` argv list."""
+
+    def opt(flag: str, key: str, cast=str) -> list[str]:
+        if key in args and args[key] not in (None, ""):
+            return [flag, str(cast(args[key]))]
+        return []
+
+    def flag(name_flag: str, key: str) -> list[str]:
+        return [name_flag] if args.get(key) else []
+
+    mapping = {
+        "scan": ["scan", *opt("--max", "max_files", int), *opt("--min-risk", "min_risk", float)],
+        "status": ["status"],
+        "commit_history": ["history", *opt("--limit", "limit", int)],
+        "bus_factor": [
+            "bus-factor",
+            *flag("--critical", "critical"),
+            *opt("--max", "max_files", int),
+        ],
+        "debt": ["debt", *opt("--rate", "rate", float), *opt("--file", "file")],
+        "protect_add": [
+            "protect", "add", str(args.get("file_path", "")),
+            *opt("--threshold", "threshold", float),
+            *opt("--label", "label"),
+        ],
+        "protect_remove": ["protect", "remove", str(args.get("file_path", ""))],
+        "protect_list": ["protect", "list"],
+        "protect_check": ["protect", "check"],
+        "sprint_create": [
+            "sprint", "create",
+            "--name", str(args.get("name", "")),
+            "--start", str(args.get("start", "")),
+            "--end", str(args.get("end", "")),
+        ],
+        "sprint_health": ["sprint", "health"],
+        "sprint_history": ["sprint", "history", *opt("--limit", "limit", int)],
+        "export": ["export", *opt("--format", "fmt"), *opt("--output", "output")],
+        "webhook_show": ["webhook", "--show"],
+        "webhook_test": ["webhook", "--test"],
+        "webhook_reset": ["webhook", "--reset"],
+        "watch": [
+            "watch",
+            *opt("--interval", "interval", int),
+            *flag("--once", "once"),
+            *flag("--notify", "notify"),
+        ],
+        "report": ["report"],
+        "doctor": ["doctor"],
+    }
+
+    if name not in mapping:
+        raise ValueError(f"Unknown tool name returned by Needle: {name!r}")
+    return mapping[name]
+
+
+# Commands that change state. At the current model accuracy, a misrouted
+# request here (e.g. "protect" resolving to protect_remove instead of
+# protect_add) can do the opposite of what the user asked. These always
+# require an explicit confirmation, regardless of --dry-run.
+_MUTATING_TOOLS = {
+    "protect_add",
+    "protect_remove",
+    "sprint_create",
+    "webhook_reset",
+}
+
+
+# ---------------------------------------------------------------------------
+# Public entrypoint
+# ---------------------------------------------------------------------------
+
+def route_command(user_query: str, dry_run: bool = False) -> None:
+    """Parse `user_query` with Needle and run the matching codedna command(s)."""
+    _ensure_model_loaded()
+
+    raw = generate(
+        _MODEL, _PARAMS, _TOKENIZER,
+        query=user_query,
+        tools=_load_tools(),
+        stream=False,
+    )
+
+    try:
+        calls = json.loads(raw)
+    except json.JSONDecodeError:
+        print(f"Unexpected output from Needle: {raw}", file=sys.stderr)
+        return
+
+    if not calls:
+        print("Could not match that request to a known command. Try rephrasing.")
+        return
+
+    for call in calls:
+        name = call.get("name")
+        args = call.get("arguments", {})
+        try:
+            argv = _build_argv(name, args)
+        except ValueError as exc:
+            print(str(exc), file=sys.stderr)
+            continue
+
+        full_cmd = ["codedna", *argv]
+        print(f"-> {' '.join(full_cmd)}")
+
+        if dry_run:
+            continue
+
+        if name in _MUTATING_TOOLS:
+            # Needle is a small (26M parameter) model and can misroute
+            # requests, especially the difference between "protect" and
+            # "unprotect" intents. Never run a state-changing command
+            # silently — always get an explicit yes from the user first.
+            answer = input("Run this command? [y/N] ").strip().lower()
+            if answer not in ("y", "yes"):
+                print("Skipped.")
+                continue
+
+        subprocess.run(full_cmd)
+
+
+if __name__ == "__main__":
+    query = " ".join(sys.argv[1:])
+    if not query:
+        print("Usage: python -m codedna.nl '<your request in natural language>'")
+        sys.exit(1)
+    route_command(query)

codedna-0.9.3/codedna/nl_tools.json

@@ -0,0 +1,127 @@
+[
+  {
+    "name": "scan",
+    "description": "Scan the current repo and show an AI-generated code risk report.",
+    "parameters": {
+      "max_files": {"type": "integer", "description": "Maximum number of files to scan. Defaults to 200.", "required": false},
+      "min_risk": {"type": "number", "description": "Minimum AI probability filter, 0.0 to 1.0.", "required": false}
+    }
+  },
+  {
+    "name": "status",
+    "description": "Show the AI score and commit message quality for the last commit.",
+    "parameters": {}
+  },
+  {
+    "name": "commit_history",
+    "description": "Show a table of past commits with their AI scores and understanding scores. This is about commit history, not sprint history.",
+    "parameters": {
+      "limit": {"type": "integer", "description": "Number of past commits to show. Defaults to 20.", "required": false}
+    }
+  },
+  {
+    "name": "bus_factor",
+    "description": "Run repo-wide bus factor analysis and show ownership risks.",
+    "parameters": {
+      "critical": {"type": "boolean", "description": "Show only critical files where bus factor equals 1.", "required": false},
+      "max_files": {"type": "integer", "description": "Maximum number of files to process. Defaults to 500.", "required": false}
+    }
+  },
+  {
+    "name": "debt",
+    "description": "Calculate technical debt cost in dollars for the whole repository. Only set the file parameter if the user names a specific file path explicitly.",
+    "parameters": {
+      "rate": {"type": "number", "description": "Hourly developer rate in dollars. Defaults to 75.", "required": false},
+      "file": {"type": "string", "description": "An actual file path, e.g. 'src/auth.py'. Do not fill this with a description or topic — only a real path the user typed.", "required": false}
+    }
+  },
+  {
+    "name": "protect_add",
+    "description": "Add protection to a file or directory so AI is not allowed to edit it. Use this when the user wants to START protecting, guard, or lock a path. This is the opposite of protect_remove.",
+    "parameters": {
+      "file_path": {"type": "string", "description": "Path to protect, e.g. 'auth/' or 'payment/login.py'.", "required": true},
+      "threshold": {"type": "number", "description": "Minimum required understanding score, 0 to 5. Defaults to 3.5.", "required": false},
+      "label": {"type": "string", "description": "Human-readable label for this protected module.", "required": false}
+    }
+  },
+  {
+    "name": "protect_remove",
+    "description": "Remove protection from a previously protected file, so AI is allowed to edit it again. Use this when the user wants to STOP, unprotect, lift protection, or remove the protected status from a path. This is the opposite of protect_add.",
+    "parameters": {
+      "file_path": {"type": "string", "description": "Path to unprotect.", "required": true}
+    }
+  },
+  {
+    "name": "protect_list",
+    "description": "Show all protected modules and their current status.",
+    "parameters": {}
+  },
+  {
+    "name": "protect_check",
+    "description": "Show only protected modules that currently violate their understanding threshold.",
+    "parameters": {}
+  },
+  {
+    "name": "sprint_create",
+    "description": "Create a new sprint and calculate its health score.",
+    "parameters": {
+      "name": {"type": "string", "description": "Sprint name, e.g. 'Sprint 14'.", "required": true},
+      "start": {"type": "string", "description": "Start date in YYYY-MM-DD format.", "required": true},
+      "end": {"type": "string", "description": "End date in YYYY-MM-DD format.", "required": true}
+    }
+  },
+  {
+    "name": "sprint_health",
+    "description": "Show the latest sprint's health score, velocity, and quality.",
+    "parameters": {}
+  },
+  {
+    "name": "sprint_history",
+    "description": "Show past sprints as a table.",
+    "parameters": {
+      "limit": {"type": "integer", "description": "Number of past sprints to show. Defaults to 10.", "required": false}
+    }
+  },
+  {
+    "name": "export",
+    "description": "Export all CodeDNA data as JSON or CSV.",
+    "parameters": {
+      "fmt": {"type": "string", "description": "Export format: 'json' or 'csv'. Defaults to json.", "required": false},
+      "output": {"type": "string", "description": "Output file path. If omitted, prints to stdout.", "required": false}
+    }
+  },
+  {
+    "name": "webhook_show",
+    "description": "Show the current Slack or Discord webhook configuration.",
+    "parameters": {}
+  },
+  {
+    "name": "webhook_test",
+    "description": "Send a test webhook notification to Slack or Discord.",
+    "parameters": {}
+  },
+  {
+    "name": "webhook_reset",
+    "description": "Clear the current webhook configuration.",
+    "parameters": {}
+  },
+  {
+    "name": "watch",
+    "description": "Watch the git repo for new commits and analyze them automatically.",
+    "parameters": {
+      "interval": {"type": "integer", "description": "Poll interval in seconds. Defaults to 30.", "required": false},
+      "once": {"type": "boolean", "description": "Run once and exit, useful for cron jobs.", "required": false},
+      "notify": {"type": "boolean", "description": "Send a webhook notification when a new commit is found.", "required": false}
+    }
+  },
+  {
+    "name": "report",
+    "description": "Generate an HTML report for the repo.",
+    "parameters": {}
+  },
+  {
+    "name": "doctor",
+    "description": "Run a system health check on the CodeDNA installation itself (dependencies, config, database). This is about the CodeDNA tool's own health, not sprint health or project health.",
+    "parameters": {}
+  }
+]

{codedna-0.9.1 → codedna-0.9.3}/codedna/scorer.py

@@ -74,7 +74,8 @@ def calculate_single_commit_ratio(repo: Repo, file_path: str) -> float:
         largest = max(commit_contributions)
         return min(largest / total, 1.0)
 
-    except Exception:
+    except Exception as exc:
+        console.log(f"[dim]single_commit_ratio error for {file_path}: {exc}[/dim]")
         return 0.0
 
 
@@ -141,7 +142,10 @@ def scan_repository(
         if file.suffix.lower() not in supported_extensions:
             continue
 
-        relative_path = str(file.relative_to(root))
+        # Use POSIX (forward-slash) paths so they match `git ls-files` output on
+        # Windows too (relative_to() yields backslashes there → never matched the
+        # tracked set → scan returned 0 files on Windows).
+        relative_path = file.relative_to(root).as_posix()
 
         # Key fix: when a Git repo is present, scan ONLY git-tracked files.
         # This automatically excludes all build/generated files in .gitignore.

{codedna-0.9.1 → codedna-0.9.3}/codedna/tech_debt.py

@@ -128,7 +128,7 @@ def calculate_file_debt(
         try:
             from codedna.analyzer import analyze_file
             result = analyze_file(p)
-            if result.desteklenmiyor or result.hata:
+            if result.unsupported or result.error:
                 return None
             ai = result.ai_probability
             complexity = result.complexity_score

{codedna-0.9.1 → codedna-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codedna"
-version = "0.9.1"
+version = "0.9.3"
 description = "AI Code Transparency Tool — detect AI-written code, analyze commit quality, track understanding debt, sprint health, bus factor, and more"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -50,11 +50,15 @@ dependencies = [
 dashboard = [
     "next-cmd>=0.5.0",  # Next.js process management
 ]
+nl = [
+    "huggingface_hub",
+    "pyarrow>=14,<18",
+]
 dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-    "black>=24.0.0",
-    "ruff>=0.1.0",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "black>=26.5.1",
+    "ruff>=0.15.19",
 ]
 
 [project.urls]
@@ -66,6 +70,9 @@ Changelog = "https://github.com/natureco-official/codedna/blob/main/CHANGELOG.md
 [project.scripts]
 codedna = "codedna.cli:main"
 
+[tool.hatch.metadata]
+allow-direct-references = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"