codeframe-ai 0.9.0__py3-none-any.whl

codeframe/core/proof/capture.py

@@ -0,0 +1,79 @@
+"""PROOF9 capture logic.
+
+Orchestrates the creation of a new requirement from a glitch report:
+classify → obligations → scope → save → generate stubs.
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from codeframe.core.proof import ledger
+from codeframe.core.proof.models import (
+    Gate,
+    Requirement,
+    Severity,
+    Source,
+)
+from codeframe.core.proof.obligations import (
+    classify_glitch,
+    get_obligations,
+    suggest_evidence_rules,
+)
+from codeframe.core.proof.scope import build_scope_from_capture
+from codeframe.core.proof.stubs import generate_stubs
+from codeframe.core.workspace import Workspace
+
+
+def capture_requirement(
+    workspace: Workspace,
+    *,
+    title: str,
+    description: str,
+    where: str,
+    severity: Severity,
+    source: Source,
+    created_by: str = "human",
+    source_issue: Optional[str] = None,
+) -> tuple[Requirement, dict[Gate, str]]:
+    """Create a new requirement from a glitch report.
+
+    Returns the saved Requirement and a dict of Gate → stub content.
+    """
+    # 1. Classify the glitch
+    glitch_type = classify_glitch(description)
+
+    # 2. Get obligation set
+    obligations = get_obligations(glitch_type)
+
+    # 3. Build scope from user-provided location
+    scope = build_scope_from_capture(where)
+
+    # 4. Generate evidence rules for each obligation
+    evidence_rules = []
+    for obl in obligations:
+        evidence_rules.extend(suggest_evidence_rules(obl.gate, title))
+
+    # 5. Create the requirement
+    req_id = ledger.next_req_id(workspace)
+    req = Requirement(
+        id=req_id,
+        title=title,
+        description=description,
+        severity=severity,
+        source=source,
+        scope=scope,
+        obligations=obligations,
+        evidence_rules=evidence_rules,
+        created_at=datetime.now(timezone.utc),
+        created_by=created_by,
+        source_issue=source_issue,
+        glitch_type=glitch_type,
+    )
+
+    # 6. Persist
+    ledger.save_requirement(workspace, req)
+
+    # 7. Generate test stubs
+    stubs = generate_stubs(req)
+
+    return req, stubs

codeframe/core/proof/evidence.py

@@ -0,0 +1,56 @@
+"""PROOF9 evidence attachment and verification.
+
+Attaches evidence artifacts (test results, screenshots, reports)
+to requirements with SHA-256 checksums for integrity.
+"""
+
+import hashlib
+from datetime import datetime, timezone
+from pathlib import Path
+
+from codeframe.core.proof import ledger
+from codeframe.core.proof.models import Evidence, Gate, Requirement
+from codeframe.core.workspace import Workspace
+
+
+def _sha256(file_path: str) -> str:
+    """Compute SHA-256 checksum of a file. Raises if file missing."""
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Artifact not found: {file_path}")
+    h = hashlib.sha256()
+    h.update(path.read_bytes())
+    return h.hexdigest()
+
+
+def attach_evidence(
+    workspace: Workspace,
+    req_id: str,
+    gate: Gate,
+    artifact_path: str,
+    satisfied: bool,
+    run_id: str,
+) -> Evidence:
+    """Create and persist an evidence record with artifact checksum."""
+    evidence = Evidence(
+        req_id=req_id,
+        gate=gate,
+        satisfied=satisfied,
+        artifact_path=artifact_path,
+        artifact_checksum=_sha256(artifact_path),
+        timestamp=datetime.now(timezone.utc),
+        run_id=run_id,
+    )
+    ledger.save_evidence(workspace, evidence)
+    return evidence
+
+
+def check_obligation_satisfied(
+    workspace: Workspace, req: Requirement, gate: Gate
+) -> bool:
+    """Check if a gate obligation has passing evidence."""
+    evidence_list = ledger.list_evidence(workspace, req.id)
+    for ev in evidence_list:
+        if ev.gate == gate and ev.satisfied:
+            return True
+    return False

codeframe/core/proof/ledger.py

@@ -0,0 +1,574 @@
+"""PROOF9 ledger — SQLite storage for requirements and evidence.
+
+Uses raw sqlite3 following the workspace pattern in core/prd.py.
+Tables live in the workspace's state.db alongside PRDs and tasks.
+"""
+
+import json
+from datetime import date, datetime, timezone
+from typing import Optional
+
+from codeframe.core.proof.models import (
+    Evidence,
+    EvidenceRule,
+    Gate,
+    GlitchType,
+    Obligation,
+    ProofRun,
+    ReqStatus,
+    Requirement,
+    RequirementScope,
+    Severity,
+    Source,
+    Waiver,
+)
+from codeframe.core.workspace import Workspace, get_db_connection
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def init_proof_tables(workspace: Workspace) -> None:
+    """Create proof tables if they don't exist."""
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS proof_requirements (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            description TEXT NOT NULL,
+            severity TEXT NOT NULL,
+            source TEXT NOT NULL,
+            scope TEXT NOT NULL,
+            obligations TEXT NOT NULL,
+            evidence_rules TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'open',
+            waiver TEXT,
+            created_at TEXT NOT NULL,
+            satisfied_at TEXT,
+            created_by TEXT NOT NULL DEFAULT '',
+            source_issue TEXT,
+            related_reqs TEXT NOT NULL DEFAULT '[]',
+            glitch_type TEXT,
+            workspace_id TEXT NOT NULL
+        )
+    """)
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS proof_evidence (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            req_id TEXT NOT NULL,
+            gate TEXT NOT NULL,
+            satisfied INTEGER NOT NULL,
+            artifact_path TEXT NOT NULL,
+            artifact_checksum TEXT NOT NULL,
+            timestamp TEXT NOT NULL,
+            run_id TEXT NOT NULL,
+            workspace_id TEXT NOT NULL,
+            FOREIGN KEY (req_id) REFERENCES proof_requirements(id)
+        )
+    """)
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS proof_runs (
+            run_id TEXT NOT NULL,
+            workspace_id TEXT NOT NULL,
+            started_at TEXT NOT NULL,
+            completed_at TEXT,
+            triggered_by TEXT NOT NULL DEFAULT 'human',
+            overall_passed INTEGER NOT NULL DEFAULT 0,
+            duration_ms INTEGER,
+            PRIMARY KEY (run_id, workspace_id)
+        )
+    """)
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS pr_proof_snapshots (
+            pr_number INTEGER NOT NULL,
+            workspace_id TEXT NOT NULL,
+            gates_passed INTEGER NOT NULL,
+            gates_total INTEGER NOT NULL,
+            gate_breakdown TEXT NOT NULL,
+            snapshotted_at TEXT NOT NULL,
+            PRIMARY KEY (pr_number, workspace_id)
+        )
+    """)
+
+    conn.commit()
+    conn.close()
+
+
+def _ensure_tables(workspace: Workspace) -> None:
+    """Lazily init tables on first access."""
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='proof_requirements'"
+    )
+    missing = not cursor.fetchone()
+    if not missing:
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='proof_runs'"
+        )
+        missing = not cursor.fetchone()
+    if not missing:
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='pr_proof_snapshots'"
+        )
+        missing = not cursor.fetchone()
+    conn.close()
+    if missing:
+        init_proof_tables(workspace)
+
+
+# --- Serialization helpers ---
+
+def _scope_to_json(scope: RequirementScope) -> str:
+    return json.dumps({
+        "routes": scope.routes,
+        "components": scope.components,
+        "apis": scope.apis,
+        "files": scope.files,
+        "tags": scope.tags,
+    })
+
+
+def _scope_from_json(raw: str) -> RequirementScope:
+    data = json.loads(raw)
+    return RequirementScope(
+        routes=data.get("routes", []),
+        components=data.get("components", []),
+        apis=data.get("apis", []),
+        files=data.get("files", []),
+        tags=data.get("tags", []),
+    )
+
+
+def _obligations_to_json(obligations: list[Obligation]) -> str:
+    return json.dumps([{"gate": o.gate.value, "status": o.status} for o in obligations])
+
+
+def _obligations_from_json(raw: str) -> list[Obligation]:
+    data = json.loads(raw)
+    return [Obligation(gate=Gate(d["gate"]), status=d.get("status", "pending")) for d in data]
+
+
+def _evidence_rules_to_json(rules: list[EvidenceRule]) -> str:
+    return json.dumps([{"test_id": r.test_id, "must_pass": r.must_pass} for r in rules])
+
+
+def _evidence_rules_from_json(raw: str) -> list[EvidenceRule]:
+    data = json.loads(raw)
+    return [EvidenceRule(test_id=d["test_id"], must_pass=d.get("must_pass", True)) for d in data]
+
+
+def _waiver_to_json(waiver: Optional[Waiver]) -> Optional[str]:
+    if waiver is None:
+        return None
+    return json.dumps({
+        "reason": waiver.reason,
+        "expires": waiver.expires.isoformat() if waiver.expires else None,
+        "manual_checklist": waiver.manual_checklist,
+        "approved_by": waiver.approved_by,
+        "waived_at": waiver.waived_at.isoformat() if waiver.waived_at else None,
+    })
+
+
+def _waiver_from_json(raw: Optional[str]) -> Optional[Waiver]:
+    if not raw:
+        return None
+    data = json.loads(raw)
+    waived_at_raw = data.get("waived_at")
+    return Waiver(
+        reason=data["reason"],
+        expires=date.fromisoformat(data["expires"]) if data.get("expires") else None,
+        manual_checklist=data.get("manual_checklist", []),
+        approved_by=data.get("approved_by", ""),
+        waived_at=datetime.fromisoformat(waived_at_raw) if waived_at_raw else None,
+    )
+
+
+def _row_to_requirement(row: tuple) -> Requirement:
+    return Requirement(
+        id=row[0],
+        title=row[1],
+        description=row[2],
+        severity=Severity(row[3]),
+        source=Source(row[4]),
+        scope=_scope_from_json(row[5]),
+        obligations=_obligations_from_json(row[6]),
+        evidence_rules=_evidence_rules_from_json(row[7]),
+        status=ReqStatus(row[8]),
+        waiver=_waiver_from_json(row[9]),
+        created_at=datetime.fromisoformat(row[10]),
+        satisfied_at=datetime.fromisoformat(row[11]) if row[11] else None,
+        created_by=row[12],
+        source_issue=row[13],
+        related_reqs=json.loads(row[14]) if row[14] else [],
+        glitch_type=GlitchType(row[15]) if row[15] else None,
+    )
+
+
+# --- CRUD ---
+
+def save_requirement(workspace: Workspace, req: Requirement) -> None:
+    """Insert or replace a requirement in the ledger."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """INSERT OR REPLACE INTO proof_requirements
+           (id, title, description, severity, source, scope, obligations,
+            evidence_rules, status, waiver, created_at, satisfied_at,
+            created_by, source_issue, related_reqs, glitch_type, workspace_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            req.id, req.title, req.description, req.severity.value,
+            req.source.value, _scope_to_json(req.scope),
+            _obligations_to_json(req.obligations),
+            _evidence_rules_to_json(req.evidence_rules),
+            req.status.value, _waiver_to_json(req.waiver),
+            (req.created_at or _utc_now()).isoformat(),
+            req.satisfied_at.isoformat() if req.satisfied_at else None,
+            req.created_by, req.source_issue,
+            json.dumps(req.related_reqs),
+            req.glitch_type.value if req.glitch_type else None,
+            workspace.id,
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_requirement(workspace: Workspace, req_id: str) -> Optional[Requirement]:
+    """Fetch a single requirement by ID."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT id, title, description, severity, source, scope, obligations,
+                  evidence_rules, status, waiver, created_at, satisfied_at,
+                  created_by, source_issue, related_reqs, glitch_type
+           FROM proof_requirements WHERE id = ? AND workspace_id = ?""",
+        (req_id, workspace.id),
+    )
+    row = cursor.fetchone()
+    conn.close()
+    return _row_to_requirement(row) if row else None
+
+
+def list_requirements(
+    workspace: Workspace, status: Optional[ReqStatus] = None
+) -> list[Requirement]:
+    """List all requirements, optionally filtered by status."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    if status:
+        cursor.execute(
+            """SELECT id, title, description, severity, source, scope, obligations,
+                      evidence_rules, status, waiver, created_at, satisfied_at,
+                      created_by, source_issue, related_reqs, glitch_type
+               FROM proof_requirements WHERE workspace_id = ? AND status = ?
+               ORDER BY created_at DESC""",
+            (workspace.id, status.value),
+        )
+    else:
+        cursor.execute(
+            """SELECT id, title, description, severity, source, scope, obligations,
+                      evidence_rules, status, waiver, created_at, satisfied_at,
+                      created_by, source_issue, related_reqs, glitch_type
+               FROM proof_requirements WHERE workspace_id = ?
+               ORDER BY created_at DESC""",
+            (workspace.id,),
+        )
+    rows = cursor.fetchall()
+    conn.close()
+    return [_row_to_requirement(r) for r in rows]
+
+
+def next_req_id(workspace: Workspace) -> str:
+    """Generate the next sequential REQ-#### ID.
+
+    Uses MAX(id) to avoid collisions from deleted requirements.
+    """
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        "SELECT MAX(CAST(SUBSTR(id, 5) AS INTEGER)) FROM proof_requirements WHERE workspace_id = ?",
+        (workspace.id,),
+    )
+    row = cursor.fetchone()
+    max_num = row[0] if row and row[0] is not None else 0
+    conn.close()
+    return f"REQ-{max_num + 1:04d}"
+
+
+def save_evidence(workspace: Workspace, evidence: Evidence) -> None:
+    """Store an evidence record."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """INSERT INTO proof_evidence
+           (req_id, gate, satisfied, artifact_path, artifact_checksum,
+            timestamp, run_id, workspace_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            evidence.req_id, evidence.gate.value, int(evidence.satisfied),
+            evidence.artifact_path, evidence.artifact_checksum,
+            evidence.timestamp.isoformat(), evidence.run_id, workspace.id,
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def list_evidence(workspace: Workspace, req_id: str) -> list[Evidence]:
+    """List all evidence for a requirement."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT req_id, gate, satisfied, artifact_path, artifact_checksum,
+                  timestamp, run_id
+           FROM proof_evidence WHERE req_id = ? AND workspace_id = ?
+           ORDER BY timestamp DESC""",
+        (req_id, workspace.id),
+    )
+    rows = cursor.fetchall()
+    conn.close()
+    return [
+        Evidence(
+            req_id=r[0], gate=Gate(r[1]), satisfied=bool(r[2]),
+            artifact_path=r[3], artifact_checksum=r[4],
+            timestamp=datetime.fromisoformat(r[5]), run_id=r[6],
+        )
+        for r in rows
+    ]
+
+
+def waive_requirement(
+    workspace: Workspace, req_id: str, waiver: Waiver
+) -> Optional[Requirement]:
+    """Waive a requirement with reason and optional expiry."""
+    if waiver.waived_at is None:
+        waiver = Waiver(
+            reason=waiver.reason,
+            expires=waiver.expires,
+            manual_checklist=waiver.manual_checklist,
+            approved_by=waiver.approved_by,
+            waived_at=datetime.now(timezone.utc),
+        )
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """UPDATE proof_requirements SET status = ?, waiver = ?
+           WHERE id = ? AND workspace_id = ?""",
+        (ReqStatus.WAIVED.value, _waiver_to_json(waiver), req_id, workspace.id),
+    )
+    conn.commit()
+    conn.close()
+    return get_requirement(workspace, req_id)
+
+
+def save_run(workspace: Workspace, run: ProofRun) -> None:
+    """Insert or replace a proof run record."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """INSERT OR REPLACE INTO proof_runs
+           (run_id, workspace_id, started_at, completed_at, triggered_by,
+            overall_passed, duration_ms)
+           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+        (
+            run.run_id, workspace.id,
+            run.started_at.isoformat(),
+            run.completed_at.isoformat() if run.completed_at else None,
+            run.triggered_by,
+            int(run.overall_passed),
+            run.duration_ms,
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_run(workspace: Workspace, run_id: str) -> Optional[ProofRun]:
+    """Fetch a single proof run by run_id."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT run_id, workspace_id, started_at, completed_at, triggered_by,
+                  overall_passed, duration_ms
+           FROM proof_runs WHERE run_id = ? AND workspace_id = ?""",
+        (run_id, workspace.id),
+    )
+    row = cursor.fetchone()
+    conn.close()
+    if not row:
+        return None
+    return ProofRun(
+        run_id=row[0],
+        workspace_id=row[1],
+        started_at=datetime.fromisoformat(row[2]),
+        completed_at=datetime.fromisoformat(row[3]) if row[3] else None,
+        triggered_by=row[4],
+        overall_passed=bool(row[5]),
+        duration_ms=row[6],
+    )
+
+
+def list_runs(workspace: Workspace, limit: int = 5) -> list[ProofRun]:
+    """List the most recent proof runs for this workspace."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT run_id, workspace_id, started_at, completed_at, triggered_by,
+                  overall_passed, duration_ms
+           FROM proof_runs WHERE workspace_id = ?
+           ORDER BY started_at DESC LIMIT ?""",
+        (workspace.id, limit),
+    )
+    rows = cursor.fetchall()
+    conn.close()
+    return [
+        ProofRun(
+            run_id=r[0],
+            workspace_id=r[1],
+            started_at=datetime.fromisoformat(r[2]),
+            completed_at=datetime.fromisoformat(r[3]) if r[3] else None,
+            triggered_by=r[4],
+            overall_passed=bool(r[5]),
+            duration_ms=r[6],
+        )
+        for r in rows
+    ]
+
+
+def get_run_evidence(workspace: Workspace, run_id: str) -> list[Evidence]:
+    """List all evidence records for a specific run_id."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT req_id, gate, satisfied, artifact_path, artifact_checksum,
+                  timestamp, run_id
+           FROM proof_evidence WHERE run_id = ? AND workspace_id = ?
+           ORDER BY timestamp ASC""",
+        (run_id, workspace.id),
+    )
+    rows = cursor.fetchall()
+    conn.close()
+    return [
+        Evidence(
+            req_id=r[0], gate=Gate(r[1]), satisfied=bool(r[2]),
+            artifact_path=r[3], artifact_checksum=r[4],
+            timestamp=datetime.fromisoformat(r[5]), run_id=r[6],
+        )
+        for r in rows
+    ]
+
+
+def check_expired_waivers(workspace: Workspace) -> list[Requirement]:
+    """Find and revert expired waivers to open status."""
+    _ensure_tables(workspace)
+    today = date.today().isoformat()
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+
+    # Find waived reqs
+    cursor.execute(
+        """SELECT id, title, description, severity, source, scope, obligations,
+                  evidence_rules, status, waiver, created_at, satisfied_at,
+                  created_by, source_issue, related_reqs, glitch_type
+           FROM proof_requirements WHERE workspace_id = ? AND status = 'waived'""",
+        (workspace.id,),
+    )
+    rows = cursor.fetchall()
+    expired = []
+
+    for row in rows:
+        req = _row_to_requirement(row)
+        if req.waiver and req.waiver.expires and req.waiver.expires.isoformat() <= today:
+            cursor.execute(
+                "UPDATE proof_requirements SET status = 'open', waiver = NULL WHERE id = ?",
+                (req.id,),
+            )
+            req.status = ReqStatus.OPEN
+            req.waiver = None
+            expired.append(req)
+
+    if expired:
+        conn.commit()
+    conn.close()
+    return expired
+
+
+# --- PR Proof Snapshots ---
+
+
+def save_pr_proof_snapshot(
+    workspace: Workspace,
+    pr_number: int,
+    gates_passed: int,
+    gates_total: int,
+    gate_breakdown: list[dict],
+) -> None:
+    """Save a proof snapshot for a PR at creation time."""
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """INSERT OR REPLACE INTO pr_proof_snapshots
+           (pr_number, workspace_id, gates_passed, gates_total,
+            gate_breakdown, snapshotted_at)
+           VALUES (?, ?, ?, ?, ?, ?)""",
+        (
+            pr_number,
+            workspace.id,
+            gates_passed,
+            gates_total,
+            json.dumps(gate_breakdown),
+            _utc_now().isoformat(),
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_pr_proof_snapshot(
+    workspace: Workspace, pr_number: int
+) -> Optional[dict]:
+    """Fetch a proof snapshot for a PR.
+
+    Returns:
+        Dict with pr_number, gates_passed, gates_total, gate_breakdown,
+        snapshotted_at — or None if not found.
+    """
+    _ensure_tables(workspace)
+    conn = get_db_connection(workspace)
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT pr_number, gates_passed, gates_total, gate_breakdown, snapshotted_at
+           FROM pr_proof_snapshots WHERE pr_number = ? AND workspace_id = ?""",
+        (pr_number, workspace.id),
+    )
+    row = cursor.fetchone()
+    conn.close()
+    if not row:
+        return None
+    return {
+        "pr_number": row[0],
+        "gates_passed": row[1],
+        "gates_total": row[2],
+        "gate_breakdown": json.loads(row[3]),
+        "snapshotted_at": row[4],
+    }