debtpilot 0.2.0__tar.gz → 0.3.0__tar.gz

{debtpilot-0.2.0 → debtpilot-0.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: debtpilot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Track technical debt before it blows up in production
 License: MIT
-Project-URL: Homepage, https://github.com/YOUR_GITHUB_USERNAME/debtpilot
-Project-URL: Issues, https://github.com/YOUR_GITHUB_USERNAME/debtpilot/issues
+Project-URL: Homepage, https://github.com/Bitxn/debtpilot
+Project-URL: Issues, https://github.com/Bitxn/debtpilot/issues
 Keywords: technical-debt,code-quality,developer-tools,cli,linting
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
@@ -100,6 +100,18 @@ lint issues (20%) + stale TODOs (15%) + staleness (10%).
 
 ---
 
+## Where your data lives
+
+Scan results are stored **per project**, in a `.debtpilot/` folder at your
+project root (found the same way git finds its root). Two different projects
+scanned on the same machine never share data. The folder self-ignores via its
+own `.gitignore`, so you'll never accidentally commit your scan database.
+
+Your global settings (Gemini API key, email digest config) live separately in
+`~/.debtpilot/config.json` — those are per-user, not per-project.
+
+---
+
 ## AI Fix Suggestions (optional)
 
 Get a free Gemini API key at aistudio.google.com then:

{debtpilot-0.2.0 → debtpilot-0.3.0}/README.md

@@ -70,6 +70,18 @@ lint issues (20%) + stale TODOs (15%) + staleness (10%).
 
 ---
 
+## Where your data lives
+
+Scan results are stored **per project**, in a `.debtpilot/` folder at your
+project root (found the same way git finds its root). Two different projects
+scanned on the same machine never share data. The folder self-ignores via its
+own `.gitignore`, so you'll never accidentally commit your scan database.
+
+Your global settings (Gemini API key, email digest config) live separately in
+`~/.debtpilot/config.json` — those are per-user, not per-project.
+
+---
+
 ## AI Fix Suggestions (optional)
 
 Get a free Gemini API key at aistudio.google.com then:

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: debtpilot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Track technical debt before it blows up in production
 License: MIT
-Project-URL: Homepage, https://github.com/YOUR_GITHUB_USERNAME/debtpilot
-Project-URL: Issues, https://github.com/YOUR_GITHUB_USERNAME/debtpilot/issues
+Project-URL: Homepage, https://github.com/Bitxn/debtpilot
+Project-URL: Issues, https://github.com/Bitxn/debtpilot/issues
 Keywords: technical-debt,code-quality,developer-tools,cli,linting
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
@@ -100,6 +100,18 @@ lint issues (20%) + stale TODOs (15%) + staleness (10%).
 
 ---
 
+## Where your data lives
+
+Scan results are stored **per project**, in a `.debtpilot/` folder at your
+project root (found the same way git finds its root). Two different projects
+scanned on the same machine never share data. The folder self-ignores via its
+own `.gitignore`, so you'll never accidentally commit your scan database.
+
+Your global settings (Gemini API key, email digest config) live separately in
+`~/.debtpilot/config.json` — those are per-user, not per-project.
+
+---
+
 ## AI Fix Suggestions (optional)
 
 Get a free Gemini API key at aistudio.google.com then:

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot.egg-info/SOURCES.txt

@@ -24,6 +24,9 @@ debtpilot_core/predictor.py
 debtpilot_core/reporter.py
 debtpilot_core/scanner.py
 debtpilot_core/scorer.py
-debtpilot_core/server.py
 debtpilot_core/sync.py
-debtpilot_core/team.py
+debtpilot_core/team.py
+tests/test_daemon.py
+tests/test_hooks.py
+tests/test_project_isolation.py
+tests/test_scorer.py

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot_core/cicd.py

@@ -61,7 +61,7 @@ jobs:
             const rows = scores.slice(0, 15).map(f => {
               const name = f.filepath.split('/').pop();
               const emoji = gradeEmoji[f.grade] || '•';
-              return `| ${emoji} ${f.grade} | \`${name}\` | ${f.score.toFixed(1)} | ${f.label} |`;
+              return `| ${emoji} ${f.grade} | \\`${name}\\` | ${f.score.toFixed(1)} | ${f.label} |`;
             }).join('\\n');
 
             const avg = scores.reduce((a, b) => a + b.score, 0) / (scores.length || 1);
@@ -158,6 +158,42 @@ def generate_gitlab_ci(output_dir: str = ".") -> str:
     output_path.write_text(GITLAB_CI_YAML)
     return str(output_path)
 
+def _get_changed_files(project_dir: str, branch: Optional[str] = None) -> Optional[List[str]]:
+    """
+    Returns a list of absolute file paths changed vs the base branch,
+    or None if we can't determine a diff (falls back to full scan).
+    """
+    import subprocess
+
+    base_candidates = [branch, "origin/main", "origin/master", "main", "master"]
+    base_candidates = [b for b in base_candidates if b]
+
+    for base in base_candidates:
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--name-only", f"{base}...HEAD"],
+                capture_output=True, text=True, timeout=15, cwd=project_dir,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                rel_files = result.stdout.strip().splitlines()
+                abs_files = [str(Path(project_dir) / f) for f in rel_files]
+                return abs_files
+        except Exception:
+            continue
+
+    # Last resort — diff against the immediately previous commit
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "HEAD~1", "HEAD"],
+            capture_output=True, text=True, timeout=15, cwd=project_dir,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            rel_files = result.stdout.strip().splitlines()
+            return [str(Path(project_dir) / f) for f in rel_files]
+    except Exception:
+        pass
+
+    return None
 
 def run_ci_scan(
     project_dir: str,
@@ -174,6 +210,8 @@ def run_ci_scan(
     """
     from debtpilot_core import linter, scanner, scorer, database as db
 
+    # CI runners invoke this against an explicit project dir; pin the DB there.
+    db.set_project_root(project_dir)
     db.ensure_db()
 
     exts = {".py", ".js", ".jsx", ".ts", ".tsx", ".mjs"}
@@ -184,16 +222,34 @@ def run_ci_scan(
 
     import re
     backup_pattern = re.compile(r'_\d{14}\.py$')
-    files = []
-    for f in Path(project_dir).rglob("*"):
-        if f.suffix in exts and not any(p in ignored for p in f.parts):
-            if not backup_pattern.search(f.name):
-                files.append(str(f))
+
+    changed_files = _get_changed_files(project_dir, branch)
+
+    if changed_files is not None:
+        # Incremental mode — only scan what changed in this PR/commit
+        files = [
+            f for f in changed_files
+            if Path(f).suffix in exts
+            and not any(p in ignored for p in Path(f).parts)
+            and not backup_pattern.search(Path(f).name)
+            and Path(f).exists()
+        ]
+        print(f"⚡ Incremental scan — {len(files)} changed file(s) detected\n")
+    else:
+        # Fallback — full repo scan (first run, or git diff unavailable)
+        files = []
+        for f in Path(project_dir).rglob("*"):
+            if f.suffix in exts and not any(p in ignored for p in f.parts):
+                if not backup_pattern.search(f.name):
+                    files.append(str(f))
+        print(f"⚡ Full scan — no changed-files baseline found, scanning all {len(files)} file(s)\n")
+
+    import concurrent.futures
 
     results = []
-    print(f"\n⚡ DebtPilot CI Scan — {len(files)} files\n")
+    max_workers = min(16, (len(files) // 5) + 4)
 
-    for fp in files:
+    def _scan_one(fp):
         lint_data = linter.lint_file(fp)
         all_issues = []
         for issues in lint_data.values():
@@ -208,21 +264,31 @@ def run_ci_scan(
             todos=scan_data["todos"],
             staleness_days=scan_data["staleness_days"],
         )
-        results.append({
+        return {
             "filepath": fp,
-            "score": score_data["total"],
-            "grade": score_data["grade"],
-            "label": score_data["label"],
-            "churn_score": score_data.get("churn_score", 0),
-            "complexity_score": score_data.get("complexity_score", 0),
-            "lint_score": score_data.get("lint_score", 0),
-            "todo_score": score_data.get("todo_score", 0),
-            "staleness_score": score_data.get("staleness_score", 0),
-        })
-        grade = score_data["grade"]
-        score = score_data["total"]
-        emoji = {"A":"✅","B":"⚠️","C":"🟠","D":"🔴","F":"💀"}.get(grade, "•")
-        print(f"  {emoji} {Path(fp).name:<45} {score:>5.1f}  [{grade}]")
+            "score": score_data.total,
+            "grade": score_data.grade,
+            "label": score_data.label,
+            "churn_score": score_data.churn_score,
+            "complexity_score": score_data.complexity_score,
+            "lint_score": score_data.lint_score,
+            "todo_score": score_data.todo_score,
+            "staleness_score": score_data.staleness_score,
+        }
+
+    if files:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_fp = {executor.submit(_scan_one, fp): fp for fp in files}
+            for future in concurrent.futures.as_completed(future_to_fp):
+                try:
+                    r = future.result()
+                    results.append(r)
+                    grade, score = r["grade"], r["score"]
+                    emoji = {"A":"✅","B":"⚠️","C":"🟠","D":"🔴","F":"💀"}.get(grade, "•")
+                    print(f"  {emoji} {Path(r['filepath']).name:<45} {score:>5.1f}  [{grade}]")
+                except Exception as exc:
+                    fp = future_to_fp[future]
+                    print(f"  ⚠️  Failed to scan {Path(fp).name}: {exc}")
 
     results.sort(key=lambda x: -x["score"])
     avg = sum(r["score"] for r in results) / len(results) if results else 0

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot_core/cli.py

@@ -10,6 +10,17 @@ import time
 from pathlib import Path
 from typing import List
 
+# Windows' default console codepage (cp1252 or similar) can't encode the
+# emoji used throughout this CLI, and rich's legacy Windows renderer doesn't
+# fall back gracefully — it raises UnicodeEncodeError and crashes the whole
+# command. Force UTF-8 output before anything else touches stdout/stderr.
+for _stream in (sys.stdout, sys.stderr):
+    if hasattr(_stream, "reconfigure"):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
 try:
     from rich.console import Console
     from rich.table import Table
@@ -45,8 +56,12 @@ def _grade_style(grade: str) -> str:
 
 
 def cmd_scan(args) -> int:
-    db.ensure_db()
+    # Scan results belong to the project being scanned, so pin the DB to the
+    # target's location before touching it — this is what keeps two projects
+    # scanned on the same machine from bleeding into each other's reports.
     target = Path(args.path).resolve()
+    db.set_project_root(target if target.is_dir() else target.parent)
+    db.ensure_db()
 
     if target.is_file():
         files = [str(target)]
@@ -75,8 +90,15 @@ def cmd_scan(args) -> int:
     _cprint(f"\n[bold]DebtPilot scan[/bold] — {len(files)} file(s)\n" if HAS_RICH
             else f"\nDebtPilot scan — {len(files)} file(s)\n")
 
+    import concurrent.futures
+    import threading
+
     results = []
-    for fp in files:
+    db_lock = threading.Lock()
+    print_lock = threading.Lock()
+
+    def _process_file(fp: str):
+        """Runs in a worker thread — does the slow I/O work (git, lint) outside the lock."""
         lint_data = linter.lint_file(fp)
         all_issues = []
         for issues in lint_data.values():
@@ -89,35 +111,51 @@ def cmd_scan(args) -> int:
             lint_issues=all_issues, todos=scan_data["todos"],
             staleness_days=scan_data["staleness_days"],
         )
-        db.upsert_score(fp, score_data)
-        if scan_data["churn"]["commits"] > 0:
-            db.upsert_churn(fp, scan_data["churn"]["commits"],
-                            scan_data["churn"]["authors"], scan_data["churn"]["last_commit"])
-        for tool, issues in lint_data.items():
-            if tool != "todos" and issues:
-                db.upsert_lint(fp, tool, issues)
-        if scan_data["todos"]:
-            db.upsert_todos(fp, scan_data["todos"])
+        return fp, score_data, scan_data, lint_data
+
+    def _save_and_print(fp, score_data, scan_data, lint_data):
+        """Runs on the main thread — SQLite writes are serialized to avoid lock contention."""
+        with db_lock:
+            db.upsert_score(fp, score_data)
+            if scan_data["churn"]["commits"] > 0:
+                db.upsert_churn(fp, scan_data["churn"]["commits"],
+                                scan_data["churn"]["authors"], scan_data["churn"]["last_commit"])
+            for tool, issues in lint_data.items():
+                if tool != "todos" and issues:
+                    db.upsert_lint(fp, tool, issues)
+            if scan_data["todos"]:
+                db.upsert_todos(fp, scan_data["todos"])
 
         results.append((fp, score_data))
-        grade = score_data["grade"]
-        total = score_data["total"]
-
-        if HAS_RICH:
-            console.print(
-                f"  {GRADE_EMOJI[grade]} [bold]{Path(fp).name:<40}[/bold] "
-                f"[{_grade_style(grade)}]{total:>5.1f}[/{_grade_style(grade)}] "
-                f"[dim]{score_data['label']}[/dim]"
-            )
-        else:
-            print(f"  [{grade}] {Path(fp).name:<40} {total:>5.1f}  {score_data['label']}")
-
+        grade = score_data.grade
+        total = score_data.total
+
+        with print_lock:
+            if HAS_RICH:
+                console.print(
+                    f"  {GRADE_EMOJI[grade]} [bold]{Path(fp).name:<40}[/bold] "
+                    f"[{_grade_style(grade)}]{total:>5.1f}[/{_grade_style(grade)}] "
+                    f"[dim]{score_data.label}[/dim]"
+                )
+            else:
+                print(f"  [{grade}] {Path(fp).name:<40} {total:>5.1f}  {score_data.label}")
+    max_workers = min(32, (len(files) // 10) + 4)  # scale workers to project size, cap at 16
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_fp = {executor.submit(_process_file, fp): fp for fp in files}
+        for future in concurrent.futures.as_completed(future_to_fp):
+            try:
+                fp, score_data, scan_data, lint_data = future.result()
+                _save_and_print(fp, score_data, scan_data, lint_data)
+            except Exception as exc:
+                fp = future_to_fp[future]
+                with print_lock:
+                    _cprint(f"  ⚠️  Failed to scan {Path(fp).name}: {exc}")
     if len(results) > 1:
-        avg = sum(s["total"] for _, s in results) / len(results)
-        worst = max(results, key=lambda x: x[1]["total"])
+        avg = sum(s.total for _, s in results) / len(results)
+        worst = max(results, key=lambda x: x[1].total)
         _cprint(f"\n  Average debt score : {avg:.1f}")
-        _cprint(f"  Highest risk file  : {Path(worst[0]).name}  ({worst[1]['total']:.1f})\n")
-
+        _cprint(f"  Highest risk file  : {Path(worst[0]).name}  ({worst[1].total:.1f})\n")
     return 0
 
 
@@ -346,22 +384,24 @@ def cmd_predict(args) -> int:
         _cprint("No data yet. Run: debtpilot scan .")
         return 0
 
-    _cprint(f"\n🔮 [bold]Bug Prediction Report[/bold] — {summary['total_files']} files analysed\n"
-            if HAS_RICH else f"\nBug Prediction — {summary['total_files']} files\n")
+    _cprint(f"\n🔮 [bold]Risk Index Report[/bold] — {summary['total_files']} files analysed\n"
+            f"[dim]Heuristic prioritisation signal, not a validated prediction.[/dim]\n"
+            if HAS_RICH else f"\nRisk Index Report — {summary['total_files']} files\n"
+            f"(Heuristic prioritisation signal, not a validated prediction.)\n")
     _cprint(f"   Critical: {summary['critical']}  High: {summary['high']}  "
             f"Medium: {summary['medium']}  Low: {summary['low']}\n")
 
     for p in predictions:
         colors = {"CRITICAL":"bold red","HIGH":"red","MEDIUM":"orange3","LOW":"green"}
         risk = p["risk_level"]
-        prob = p["probability"]
+        idx = p.get("risk_index", p.get("probability", 0))
         name = Path(p["filepath"]).name
         drivers = " · ".join(p["drivers"][:2])
         if HAS_RICH:
             console.print(f"  [{colors.get(risk,'white')}]{risk:<10}[/{colors.get(risk,'white')}]"
-                          f"  {prob:>4}%  [cyan]{name:<40}[/cyan]  [dim]{drivers}[/dim]")
+                          f"  {idx:>5.1f}  [cyan]{name:<40}[/cyan]  [dim]{drivers}[/dim]")
         else:
-            print(f"  {risk:<10}  {prob:>4}%  {name:<40}  {drivers}")
+            print(f"  {risk:<10}  {idx:>5.1f}  {name:<40}  {drivers}")
     return 0
 
 

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot_core/daemon.py

@@ -98,28 +98,28 @@ async def process_file(filepath: str) -> None:
     if scan_data["todos"]:
         db.upsert_todos(filepath, scan_data["todos"])
 
-    total = score_data["total"]
+    total = score_data.total
     prev = db.get_latest_score(filepath)
     prev_score = prev["score"] if prev else 0
 
     if total >= ALERT_THRESHOLD and prev_score < ALERT_THRESHOLD:
         alert_id = db.create_alert(filepath, "debt_threshold",
-                                   f"Score crossed {ALERT_THRESHOLD}: {score_data['label']} ({total})", total)
+                                   f"Score crossed {ALERT_THRESHOLD}: {score_data.label} ({total})", total)
         await hub.broadcast({
             "event": "alert", "alert_id": alert_id, "filepath": filepath,
-            "score": total, "grade": score_data["grade"], "label": score_data["label"],
+            "score": total, "grade": score_data.grade, "label": score_data.label,
             "message": f"⚠️  {Path(filepath).name} crossed the danger threshold",
             "recommendations": scorer.top_recommendations(score_data),
         })
         # 🔔 Real desktop notification
         try:
             from debtpilot_core.notifier import alert_danger_threshold, alert_critical_file
-            if score_data["grade"] == "F":
+            if score_data.grade == "F":
                 alert_critical_file(filepath, total)
             else:
                 alert_danger_threshold(
                     filepath, total,
-                    score_data["grade"],
+                    score_data.grade,
                     scorer.top_recommendations(score_data)
                 )
         except Exception:
@@ -130,23 +130,23 @@ async def process_file(filepath: str) -> None:
                                    f"Score spiked +{total - prev_score:.1f} to {total}", total)
         await hub.broadcast({
             "event": "alert", "alert_id": alert_id, "filepath": filepath,
-            "score": total, "grade": score_data["grade"], "label": score_data["label"],
+            "score": total, "grade": score_data.grade, "label": score_data.label,
             "message": f"🔺 {Path(filepath).name} score spiked",
             "recommendations": scorer.top_recommendations(score_data),
         })
         # 🔔 Real desktop notification
         try:
             from debtpilot_core.notifier import alert_debt_spike
-            alert_debt_spike(filepath, total, score_data["grade"], score_data["label"])
+            alert_debt_spike(filepath, total, score_data.grade, score_data.label)
         except Exception:
             pass
 
     await hub.broadcast({
         "event": "score_updated", "filepath": filepath,
-        "score": total, "grade": score_data["grade"], "label": score_data["label"],
+        "score": total, "grade": score_data.grade, "label": score_data.label,
         "timestamp": int(time.time()),
     })
-    logger.info(f"[{score_data['grade']}] {Path(filepath).name}  score={total}")
+    logger.info(f"[{score_data.grade}] {Path(filepath).name}  score={total}")
 
 
 class DebtEventHandler(FileSystemEventHandler):
@@ -216,6 +216,9 @@ async def ws_handler(ws, path="/"):
 
 
 async def run_daemon(project_dir: str, port: int = DEFAULT_PORT) -> None:
+    # The daemon may be launched from a different cwd than the project it
+    # watches (e.g. Windows Task Scheduler), so pin the DB to project_dir.
+    db.set_project_root(project_dir)
     db.ensure_db()
     logger.info(f"DebtPilot daemon starting | project={project_dir} | port={port}")
     loop = asyncio.get_event_loop()

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot_core/database.py

@@ -3,6 +3,7 @@ DebtPilot - SQLite storage layer.
 Stores file debt scores, churn history, lint results, and alerts.
 """
 
+import os
 import sqlite3
 import json
 import time
@@ -11,8 +12,52 @@ from typing import Optional, List, Dict, Any
 from contextlib import contextmanager
 
 
-DB_DIR = Path.home() / ".debtpilot"
-DB_PATH = DB_DIR / "debtpilot.db"
+# ── Per-project database location ─────────────────────────────────────────────
+#
+# The scan database is scoped to a single project, NOT global. Before this,
+# every project scanned on a machine wrote into one shared ~/.debtpilot DB, so
+# `debtpilot report` in project B would show project A's files mixed in — a
+# real data-isolation defect. The DB now lives at <project-root>/.debtpilot/,
+# discovered the same way git finds its root (walk up for a .git marker),
+# falling back to the current directory.
+#
+# Note: this is separate from ~/.debtpilot/config.json, which is intentionally
+# global (your Gemini key and email settings are per-user, not per-project).
+
+_DB_FILENAME = "debtpilot.db"
+_project_root_override: Optional[Path] = None
+_db_path_cache: Optional[Path] = None
+
+
+def set_project_root(path) -> None:
+    """
+    Force which project the DB belongs to. Used by the daemon and CI/CD, which
+    are handed an explicit project directory that may differ from cwd, and by
+    tests that need an isolated DB.
+    """
+    global _project_root_override, _db_path_cache
+    _project_root_override = Path(path).resolve()
+    _db_path_cache = None
+
+
+def _find_project_root() -> Path:
+    if _project_root_override is not None:
+        return _project_root_override
+    env = os.environ.get("DEBTPILOT_PROJECT_ROOT")
+    if env:
+        return Path(env).resolve()
+    start = Path.cwd().resolve()
+    for parent in [start] + list(start.parents):
+        if (parent / ".git").exists():
+            return parent
+    return start
+
+
+def get_db_path() -> Path:
+    global _db_path_cache
+    if _db_path_cache is None:
+        _db_path_cache = _find_project_root() / ".debtpilot" / _DB_FILENAME
+    return _db_path_cache
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS file_scores (
@@ -73,15 +118,25 @@ CREATE INDEX IF NOT EXISTS idx_alerts_filepath ON alerts(filepath);
 
 
 def ensure_db() -> None:
-    DB_DIR.mkdir(parents=True, exist_ok=True)
-    with sqlite3.connect(DB_PATH) as conn:
+    db_path = get_db_path()
+    db_dir = db_path.parent
+    db_dir.mkdir(parents=True, exist_ok=True)
+    # Self-ignore: drop a .gitignore so users never accidentally commit their
+    # local scan database (same trick pytest/mypy use for their caches).
+    gitignore = db_dir / ".gitignore"
+    if not gitignore.exists():
+        try:
+            gitignore.write_text("# Created automatically by DebtPilot\n*\n")
+        except OSError:
+            pass
+    with sqlite3.connect(db_path) as conn:
         conn.executescript(SCHEMA)
         conn.commit()
 
 
 @contextmanager
 def get_conn():
-    conn = sqlite3.connect(DB_PATH)
+    conn = sqlite3.connect(get_db_path())
     conn.row_factory = sqlite3.Row
     try:
         yield conn
@@ -93,7 +148,12 @@ def get_conn():
         conn.close()
 
 
-def upsert_score(filepath: str, score_data: Dict[str, Any]) -> None:
+def upsert_score(filepath: str, score_data) -> None:
+    """
+    score_data must be a scorer.ScoreResult — attribute access, not .get().
+    If a field is missing, this raises AttributeError immediately rather
+    than silently writing a 0, which is the exact bug class this replaces.
+    """
     now = int(time.time())
     with get_conn() as conn:
         conn.execute(
@@ -105,12 +165,12 @@ def upsert_score(filepath: str, score_data: Dict[str, Any]) -> None:
             """,
             (
                 filepath,
-                score_data.get("total", 0),
-                score_data.get("churn", 0),
-                score_data.get("complexity", 0),
-                score_data.get("lint", 0),
-                score_data.get("todo", 0),
-                score_data.get("staleness", 0),
+                score_data.total,
+                score_data.churn_score,
+                score_data.complexity_score,
+                score_data.lint_score,
+                score_data.todo_score,
+                score_data.staleness_score,
                 now,
             ),
         )

{debtpilot-0.2.0 → debtpilot-0.3.0}/debtpilot_core/enterprise_cli.py

@@ -6,6 +6,16 @@ Team management, CI/CD setup, compliance reports.
 import sys
 from pathlib import Path
 
+# See cli.py for why this is needed: Windows' default console codepage
+# can't encode the emoji this module prints, and rich's legacy Windows
+# renderer raises UnicodeEncodeError instead of degrading gracefully.
+for _stream in (sys.stdout, sys.stderr):
+    if hasattr(_stream, "reconfigure"):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
 try:
     from rich.console import Console
     from rich.table import Table