codevoight 0.1.0__py3-none-any.whl

codevoight/db/repository.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+from contextlib import contextmanager
+from typing import Iterator, List, Optional
+
+from codevoight.core.models import (
+    QuizOption,
+    QuizQuestion,
+    SessionStatus,
+    StagedSession,
+)
+from codevoight.db.schema import init_db
+
+
+class StateRepository:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._ensure_init()
+
+    @contextmanager
+    def _get_connection(self) -> Iterator[sqlite3.Connection]:
+        conn = sqlite3.connect(str(self.db_path), timeout=10.0)
+        conn.row_factory = sqlite3.Row
+        try:
+            with conn:
+                yield conn
+        finally:
+            conn.close()
+
+    def _ensure_init(self) -> None:
+        with self._get_connection() as conn:
+            init_db(conn)
+
+    def create_session(self, session: StagedSession, questions: List[QuizQuestion]) -> None:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                INSERT INTO sessions (
+                    session_id, diff_text, diff_hash, description, status,
+                    created_at, expires_at, capability_token
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    session.session_id,
+                    session.diff_text,
+                    session.diff_hash,
+                    session.description,
+                    session.status.value,
+                    session.created_at,
+                    session.expires_at,
+                    session.capability_token,
+                ),
+            )
+
+            for q in questions:
+                options_data = [opt.model_dump() for opt in q.options]
+                cursor.execute(
+                    """
+                    INSERT INTO questions (
+                        id, session_id, prompt, options_json, correct_option_id, explanation
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        q.id,
+                        session.session_id,
+                        q.prompt,
+                        json.dumps(options_data),
+                        q.correct_option_id,
+                        q.explanation,
+                    ),
+                )
+            conn.commit()
+
+    def get_session(self, session_id: str) -> Optional[StagedSession]:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM sessions WHERE session_id = ?",
+                (session_id,),
+            )
+            row = cursor.fetchone()
+            if not row:
+                return None
+            return StagedSession(
+                session_id=row["session_id"],
+                diff_text=row["diff_text"],
+                diff_hash=row["diff_hash"],
+                description=row["description"],
+                status=SessionStatus(row["status"]),
+                created_at=row["created_at"],
+                expires_at=row["expires_at"],
+                capability_token=row["capability_token"],
+            )
+
+    def get_latest_pending_session(self) -> Optional[StagedSession]:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT * FROM sessions 
+                WHERE status = ? AND expires_at > ?
+                ORDER BY created_at DESC LIMIT 1
+                """,
+                (SessionStatus.PENDING_QUIZ.value, time.time()),
+            )
+            row = cursor.fetchone()
+            if not row:
+                return None
+            return StagedSession(
+                session_id=row["session_id"],
+                diff_text=row["diff_text"],
+                diff_hash=row["diff_hash"],
+                description=row["description"],
+                status=SessionStatus(row["status"]),
+                created_at=row["created_at"],
+                expires_at=row["expires_at"],
+                capability_token=row["capability_token"],
+            )
+
+    def get_questions_for_session(self, session_id: str) -> List[QuizQuestion]:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM questions WHERE session_id = ?",
+                (session_id,),
+            )
+            rows = cursor.fetchall()
+            questions = []
+            for r in rows:
+                opts = [QuizOption(**opt) for opt in json.loads(r["options_json"])]
+                questions.append(
+                    QuizQuestion(
+                        id=r["id"],
+                        prompt=r["prompt"],
+                        options=opts,
+                        correct_option_id=r["correct_option_id"],
+                        explanation=r["explanation"],
+                    )
+                )
+            return questions
+
+    def update_session_status(
+        self, session_id: str, status: SessionStatus, token: Optional[str] = None
+    ) -> None:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            if token is not None:
+                cursor.execute(
+                    "UPDATE sessions SET status = ?, capability_token = ? WHERE session_id = ?",
+                    (status.value, token, session_id),
+                )
+            else:
+                cursor.execute(
+                    "UPDATE sessions SET status = ? WHERE session_id = ?",
+                    (status.value, session_id),
+                )
+            conn.commit()
+
+    def find_valid_approved_session(self, diff_hash: str) -> Optional[StagedSession]:
+        now = time.time()
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT * FROM sessions 
+                WHERE diff_hash = ? AND status = ? AND expires_at > ? AND capability_token IS NOT NULL
+                ORDER BY created_at DESC LIMIT 1
+                """,
+                (diff_hash, SessionStatus.APPROVED.value, now),
+            )
+            row = cursor.fetchone()
+            if not row:
+                return None
+            return StagedSession(
+                session_id=row["session_id"],
+                diff_text=row["diff_text"],
+                diff_hash=row["diff_hash"],
+                description=row["description"],
+                status=SessionStatus(row["status"]),
+                created_at=row["created_at"],
+                expires_at=row["expires_at"],
+                capability_token=row["capability_token"],
+            )
+
+    def consume_session_token(self, session_id: str) -> bool:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE sessions SET status = ? WHERE session_id = ? AND status = ?",
+                (SessionStatus.CONSUMED.value, session_id, SessionStatus.APPROVED.value),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def list_sessions(self, limit: int = 20) -> List[StagedSession]:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?",
+                (limit,),
+            )
+            rows = cursor.fetchall()
+            return [
+                StagedSession(
+                    session_id=r["session_id"],
+                    diff_text=r["diff_text"],
+                    diff_hash=r["diff_hash"],
+                    description=r["description"],
+                    status=SessionStatus(r["status"]),
+                    created_at=r["created_at"],
+                    expires_at=r["expires_at"],
+                    capability_token=r["capability_token"],
+                )
+                for r in rows
+            ]

codevoight/db/schema.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import sqlite3
+
+INIT_SCHEMA_SQL = """
+PRAGMA journal_mode=WAL;
+PRAGMA busy_timeout=5000;
+PRAGMA foreign_keys=ON;
+
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id TEXT PRIMARY KEY,
+    diff_text TEXT NOT NULL,
+    diff_hash TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    status TEXT NOT NULL,
+    created_at REAL NOT NULL,
+    expires_at REAL NOT NULL,
+    capability_token TEXT DEFAULT NULL
+);
+
+CREATE TABLE IF NOT EXISTS questions (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    options_json TEXT NOT NULL,
+    correct_option_id TEXT NOT NULL,
+    explanation TEXT DEFAULT '',
+    FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_diff_hash ON sessions(diff_hash);
+CREATE INDEX IF NOT EXISTS idx_questions_session ON questions(session_id);
+"""
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    """Initialize database tables, pragmas, and indexes."""
+    conn.executescript(INIT_SCHEMA_SQL)
+    conn.commit()

codevoight/generators/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from codevoight.core.models import QuizQuestion, QuizResult, QuizSubmission
+
+
+class BaseQuizGenerator(ABC):
+    @abstractmethod
+    def generate_quiz(self, diff_text: str, description: str = "") -> List[QuizQuestion]:
+        """Generate comprehension questions based on the diff and optional description."""
+        pass
+
+
+class BaseQuizEvaluator(ABC):
+    @abstractmethod
+    def evaluate(self, submission: QuizSubmission, questions: List[QuizQuestion]) -> QuizResult:
+        """Evaluate developer answers and determine pass/fail with feedback."""
+        pass

codevoight/generators/deterministic.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import re
+import uuid
+from typing import List, Set
+from codevoight.core.models import (
+    QuizOption,
+    QuizQuestion,
+    QuizResult,
+    QuizSubmission,
+)
+from codevoight.generators.base import BaseQuizEvaluator, BaseQuizGenerator
+
+
+class DeterministicQuizGenerator(BaseQuizGenerator):
+    """Zero-dependency, offline deterministic quiz generator based on AST/diff heuristics."""
+
+    def generate_quiz(self, diff_text: str, description: str = "") -> List[QuizQuestion]:
+        questions: List[QuizQuestion] = []
+        files = self._extract_filenames(diff_text)
+        added_lines, removed_lines = self._extract_added_removed(diff_text)
+        symbols = self._extract_symbols(diff_text)
+
+        # Question 1: File targeting
+        if files:
+            primary_file = files[0]
+            options = [
+                QuizOption(id="A", text=f"Modifies or introduces `{primary_file}`"),
+                QuizOption(id="B", text=f"Deletes all tests in `tests/test_legacy.py`"),
+                QuizOption(id="C", text=f"Replaces deployment manifests in `.k8s/`"),
+                QuizOption(id="D", text=f"Only updates documentation in `docs/architecture.md`"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt=f"Which target file is modified in this staged diff?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation=f"The diff explicitly modifies `{primary_file}`.",
+                )
+            )
+
+        # Question 2: Symbol / Function change
+        if symbols:
+            primary_symbol = symbols[0]
+            options = [
+                QuizOption(id="A", text=f"Introduces or modifies `{primary_symbol}`"),
+                QuizOption(id="B", text=f"Deprecated `{primary_symbol}_legacy`"),
+                QuizOption(id="C", text=f"Removes `{primary_symbol}` completely"),
+                QuizOption(id="D", text="Does not touch any function or class definitions"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt="Which symbol or function definition is directly affected by this diff?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation=f"The diff contains changes to `{primary_symbol}`.",
+                )
+            )
+        else:
+            # Fallback based on added content length / keywords
+            add_count = len(added_lines)
+            rem_count = len(removed_lines)
+            correct_summary = f"Adds ~{add_count} lines and removes ~{rem_count} lines"
+            options = [
+                QuizOption(id="A", text=correct_summary),
+                QuizOption(id="B", text="Deletes the entire repository database"),
+                QuizOption(id="C", text="Performs a full rollback to commit HEAD~10"),
+                QuizOption(id="D", text="Changes only binary asset files"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt="What is the net line modification profile of this change?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation=f"The diff consists of {add_count} additions and {rem_count} deletions.",
+                )
+            )
+
+        # Question 3: Semantic intent or condition
+        has_error_handling = any(
+            re.search(r"\b(raise|try|except|throw|catch|error|Err)\b", line, re.I)
+            for line in added_lines
+        )
+        has_imports = any(
+            re.search(r"^\s*(import|from|require|include)\b", line)
+            for line in added_lines
+        )
+
+        if has_error_handling:
+            options = [
+                QuizOption(id="A", text="Adds error handling, exception guards, or validation"),
+                QuizOption(id="B", text="Disables security assertions across all endpoints"),
+                QuizOption(id="C", text="Swallows exceptions with silent pass statements"),
+                QuizOption(id="D", text="Removes runtime input validation"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt="What validation or error handling behavior is added in this diff?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation="The diff introduces explicit exception handling or validation guards.",
+                )
+            )
+        elif has_imports:
+            options = [
+                QuizOption(id="A", text="Imports or imports from additional modules/libraries"),
+                QuizOption(id="B", text="Uninstalls all third-party dependencies"),
+                QuizOption(id="C", text="Converts Python code to C++ bindings"),
+                QuizOption(id="D", text="Disables external module resolution"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt="What dependency or module change is present in this diff?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation="New import statements are introduced in the staged change.",
+                )
+            )
+        else:
+            options = [
+                QuizOption(id="A", text=f"Implements: {description or 'staged logic update'}"),
+                QuizOption(id="B", text="Reverts all recent git commits"),
+                QuizOption(id="C", text="Formats code with no functional edits"),
+                QuizOption(id="D", text="Increments package version number only"),
+            ]
+            questions.append(
+                QuizQuestion(
+                    id=str(uuid.uuid4())[:8],
+                    prompt="What is the primary stated intent of this change?",
+                    options=options,
+                    correct_option_id="A",
+                    explanation="Reflects the staged change intent.",
+                )
+            )
+
+        return questions
+
+    def _extract_filenames(self, diff_text: str) -> List[str]:
+        files: List[str] = []
+        for line in diff_text.splitlines():
+            if line.startswith("+++ b/"):
+                files.append(line[6:].strip())
+            elif line.startswith("--- a/") and line[6:].strip() not in files:
+                f = line[6:].strip()
+                if f != "/dev/null":
+                    files.append(f)
+        return list(dict.fromkeys(files))
+
+    def _extract_added_removed(self, diff_text: str) -> tuple[List[str], List[str]]:
+        added = []
+        removed = []
+        for line in diff_text.splitlines():
+            if line.startswith("+") and not line.startswith("+++"):
+                added.append(line[1:].strip())
+            elif line.startswith("-") and not line.startswith("---"):
+                removed.append(line[1:].strip())
+        return added, removed
+
+    def _extract_symbols(self, diff_text: str) -> List[str]:
+        symbols: Set[str] = set()
+        pattern = re.compile(r"^\+\s*(?:async\s+)?(?:def|class|function|const|let|var)\s+([a-zA-Z0-9_]+)")
+        for line in diff_text.splitlines():
+            match = pattern.search(line)
+            if match:
+                symbols.add(match.group(1))
+        return sorted(list(symbols))
+
+
+class DeterministicQuizEvaluator(BaseQuizEvaluator):
+    """Deterministic grading engine enforcing 100% threshold by default."""
+
+    def __init__(self, passing_score: float = 1.0):
+        self.passing_score = passing_score
+
+    def evaluate(self, submission: QuizSubmission, questions: List[QuizQuestion]) -> QuizResult:
+        if not questions:
+            return QuizResult(
+                session_id=submission.session_id,
+                passed=True,
+                score=1.0,
+                total=0,
+                correct=0,
+                feedback=["No questions required for this diff."],
+            )
+
+        total = len(questions)
+        correct = 0
+        feedback: List[str] = []
+
+        for q in questions:
+            chosen = submission.answers.get(q.id)
+            if chosen == q.correct_option_id:
+                correct += 1
+                feedback.append(f"Question '{q.prompt}': Correct!")
+            else:
+                feedback.append(
+                    f"Question '{q.prompt}': Incorrect. You answered {chosen}, "
+                    f"expected {q.correct_option_id}. {q.explanation}"
+                )
+
+        score = correct / total
+        passed = score >= self.passing_score
+
+        return QuizResult(
+            session_id=submission.session_id,
+            passed=passed,
+            score=score,
+            total=total,
+            correct=correct,
+            feedback=feedback,
+        )

codevoight/generators/llm.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import os
+from typing import List, Optional
+
+from codevoight.core.models import QuizQuestion
+from codevoight.generators.base import BaseQuizGenerator
+from codevoight.generators.deterministic import DeterministicQuizGenerator
+
+
+class LLMQuizGenerator(BaseQuizGenerator):
+    """Pluggable LLM generator with automatic fallback to deterministic generator."""
+
+    def __init__(self, fallback_generator: Optional[BaseQuizGenerator] = None):
+        self.fallback = fallback_generator or DeterministicQuizGenerator()
+        self.api_key = os.getenv("CODEVOIGHT_LLM_API_KEY") or os.getenv("QUIZGATE_LLM_API_KEY") or os.getenv("CODEGATE_LLM_API_KEY") or os.getenv("OPENAI_API_KEY")
+
+    def generate_quiz(self, diff_text: str, description: str = "") -> List[QuizQuestion]:
+        # If no LLM credentials provided or in offline/test mode, seamlessly use deterministic engine
+        if not self.api_key:
+            return self.fallback.generate_quiz(diff_text, description)
+
+        try:
+            # Pluggable LLM invocation hook
+            # If external network call fails or is not configured, fallback gracefully
+            return self._call_llm_api(diff_text, description)
+        except Exception:
+            return self.fallback.generate_quiz(diff_text, description)
+
+    def _call_llm_api(self, diff_text: str, description: str = "") -> List[QuizQuestion]:
+        # Placeholder for external LLM-as-a-judge provider integration
+        # In base install, falls back safely to deterministic rules
+        return self.fallback.generate_quiz(diff_text, description)

codevoight/git/hook.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+from typing import Optional, Tuple
+
+from codevoight.core.diff import compute_diff_hash
+from codevoight.core.models import CapabilityToken
+from codevoight.core.security import get_or_create_secret, verify_token
+from codevoight.db.repository import StateRepository
+from codevoight.git.runner import GitRunner
+
+
+HOOK_SCRIPT = """#!/bin/sh
+# CodeVoight Pre-Commit Verification Hook
+# Enforces human comprehension quiz verification before git commit.
+
+if [ -f ".venv/Scripts/python.exe" ]; then
+    PYTHON=".venv/Scripts/python.exe"
+elif [ -f ".venv/bin/python" ]; then
+    PYTHON=".venv/bin/python"
+elif command -v py >/dev/null 2>&1; then
+    PYTHON=py
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON=python3
+elif command -v python >/dev/null 2>&1; then
+    PYTHON=python
+else
+    echo "[CODEVOIGHT] Error: Python runtime not found in PATH."
+    exit 1
+fi
+
+$PYTHON -m codevoight.cli verify-commit
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+    echo ""
+    echo "[CODEVOIGHT] COMMIT BLOCKED: Staged changes require human comprehension approval."
+    echo "[CODEVOIGHT] To approve, run: codevoight quiz"
+    echo ""
+    exit 1
+fi
+
+exit 0
+"""
+
+
+def install_pre_commit_hook(repo_dir: Optional[Path] = None) -> Tuple[bool, str]:
+    """Install the pre-commit hook into .git/hooks/pre-commit."""
+    runner = GitRunner(repo_dir)
+    root = runner.get_repo_root()
+    if not root:
+        return False, "Not inside a valid Git repository."
+
+    hooks_dir = root / ".git" / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    hook_file = hooks_dir / "pre-commit"
+
+    hook_file.write_text(HOOK_SCRIPT, encoding="utf-8", newline="\n")
+
+    # Set executable bit for unix/posix
+    try:
+        current_stat = os.stat(hook_file)
+        os.chmod(hook_file, current_stat.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    except Exception:
+        pass
+
+    return True, str(hook_file)
+
+
+def verify_staged_commit(workspace_root: Optional[Path] = None) -> Tuple[bool, str]:
+    """Verify that current staged Git changes have a valid, unexpired approval token."""
+    runner = GitRunner(workspace_root)
+    root = runner.get_repo_root() or (workspace_root.resolve() if workspace_root else None)
+    if not root:
+        return False, "Not inside a git repository."
+
+    staged_diff = runner.get_staged_diff()
+    if not staged_diff.strip():
+        # Nothing staged or empty commit
+        return True, "No staged diff to verify."
+
+    diff_hash = compute_diff_hash(staged_diff)
+
+    codevoight_dir = root / ".codevoight"
+    if not codevoight_dir.exists():
+        if (root / ".quizgate").exists():
+            codevoight_dir = root / ".quizgate"
+        elif (root / ".codegate").exists():
+            codevoight_dir = root / ".codegate"
+
+    db_path = codevoight_dir / "state.db"
+    if not db_path.exists():
+        return False, "No CodeVoight state found. Run 'codevoight quiz' to approve staged changes."
+
+    repo = StateRepository(db_path)
+    session = repo.find_valid_approved_session(diff_hash)
+    if not session or not session.capability_token:
+        return False, f"Diff hash {diff_hash[:12]} has not been approved via quiz."
+
+    # Verify cryptographic signature
+    secret_key = get_or_create_secret(codevoight_dir)
+    try:
+        token = CapabilityToken.parse(session.capability_token)
+    except Exception as e:
+        return False, f"Invalid token format: {e}"
+
+    is_valid = verify_token(token, diff_hash, secret_key)
+    if not is_valid:
+        return False, "Token signature invalid or expired."
+
+    return True, f"Verified capability token for session {session.session_id}."