sourcepack 1.10.0a0__py3-none-any.whl

sourcepack/paths.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def sourcepack_paths(repo: str | Path) -> dict[str, Path]:
+    root = Path(repo).resolve()
+    base = root / ".sourcepack"
+    baseline = base / "baseline"
+    prompt = base / "prompt"
+    reports = base / "reports"
+    return {
+        "root": root,
+        "base": base,
+        "current": base / "current",  # legacy compatibility marker only
+        "baseline": baseline,
+        "packet": baseline / "packet",
+        "baseline_meta": baseline / "metadata.json",
+        "prompt_dir": prompt,
+        "prompt_packet": prompt / "packet",
+        "prompt_reality": prompt / "reality_map.json",
+        "prompt_instructions": prompt / "ai_instructions.md",
+        "reports": reports,
+        "archive": reports / "archive",
+        "reality": baseline / "reality_map.json",
+        "instructions": baseline / "ai_instructions.md",
+        "prompt": prompt / "prompt.md",
+        "state": base / "state",
+        "stale_marker": base / "state" / "baseline_stale.json",
+        "latest_json": reports / "latest.json",
+        "latest_md": reports / "latest.md",
+        "latest_html": reports / "latest.html",
+        "latest_diff_json": reports / "latest_diff.json",
+        "latest_prompt_json": reports / "latest_prompt.json",
+        "latest_baseline_json": reports / "latest_baseline.json",
+        "builds": baseline / "builds",
+        "active_pointer": baseline / "active.json",
+        "baseline_lock": base / "state" / "baseline.lock",
+    }
+
+
+def ensure_sourcepack_dirs(repo: str | Path) -> dict[str, Path]:
+    paths = sourcepack_paths(repo)
+    paths["baseline"].mkdir(parents=True, exist_ok=True)
+    paths["prompt_dir"].mkdir(parents=True, exist_ok=True)
+    paths["current"].mkdir(parents=True, exist_ok=True)
+    paths["reports"].mkdir(parents=True, exist_ok=True)
+    paths["archive"].mkdir(parents=True, exist_ok=True)
+    paths["state"].mkdir(parents=True, exist_ok=True)
+    return paths
+
+
+def ensure_gitignore_entry(repo: str | Path) -> tuple[bool, str | None]:
+    path = Path(repo) / ".gitignore"
+    try:
+        if not path.exists():
+            path.write_text(".sourcepack/\n", encoding="utf-8")
+            return True, None
+        data = path.read_bytes()
+        text = data.decode("utf-8")
+        if any(line.strip() in {".sourcepack", ".sourcepack/"} for line in text.splitlines()):
+            return False, None
+        newline = "\r\n" if b"\r\n" in data else "\n"
+        addition = ("" if text.endswith(("\n", "\r\n")) or not text else newline) + ".sourcepack/" + newline
+        path.write_text(text + addition, encoding="utf-8", newline="")
+        return True, None
+    except Exception as exc:
+        return False, str(exc)

sourcepack/policy.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+class PolicyMode(StrEnum):
+    LOCAL = "local"
+    STRICT = "strict"
+    CI = "ci"
+
+
+def normalize_policy_mode(value: PolicyMode | str | None) -> PolicyMode:
+    if isinstance(value, PolicyMode):
+        return value
+    if value is None:
+        return PolicyMode.LOCAL
+    text = str(value).lower().strip()
+    if text in {"ci", "--ci"}:
+        return PolicyMode.CI
+    if text in {"strict", "--strict"}:
+        return PolicyMode.STRICT
+    return PolicyMode.LOCAL
+
+
+def commit_policy(verdict: str) -> str | None:
+    if verdict == "WARN":
+        return "allowed locally, blocked in strict mode."
+    if verdict == "FAIL":
+        return "blocked unless explicitly bypassed."
+    return None
+
+
+def exit_code(verdict: str, mode: PolicyMode | str | None = None) -> int:
+    mode = normalize_policy_mode(mode)
+    if verdict == "FAIL":
+        return 1
+    if verdict == "WARN" and mode in {PolicyMode.STRICT, PolicyMode.CI}:
+        return 1
+    return 0

sourcepack/reason_codes.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+REASON_CODE_VOCABULARY_VERSION = "reason_codes.v1"
+
+
+class ReasonCode(StrEnum):
+    BASELINE_MISSING = "baseline_missing"
+    BASELINE_STALE = "baseline_stale"
+    BASELINE_CORRUPT = "baseline_corrupt"
+    MISSING_FILE = "missing_file"
+    NEW_FILE = "new_file"
+    DELETED_FILE = "deleted_file"
+    UNSUPPORTED_DEPENDENCY = "unsupported_dependency"
+    DECLARED_DEPENDENCY = "declared_dependency"
+    DECLARED_COMMAND = "declared_command"
+    UNSUPPORTED_COMMAND = "unsupported_command"
+    UNSAFE_PATH = "unsafe_path"
+    PATH_ESCAPE = "path_escape"
+    PROTECTED_ARTIFACT = "protected_artifact"
+    GIT_PATH_MODIFICATION = "git_path_modification"
+    BINARY_DIFF = "binary_diff"
+    MALFORMED_DIFF = "malformed_diff"
+    UNSUPPORTED_ECOSYSTEM = "unsupported_ecosystem"
+    DIRTY_WORKTREE = "dirty_worktree"
+    BASELINE_LOCKED = "baseline_locked"
+    BASELINE_FAILED = "baseline_failed"
+    GIT_UNAVAILABLE = "git_unavailable"
+    NO_GIT_REPO = "no_git_repo"
+    NO_DIFF = "no_diff"
+    REPO_NOT_DIRECTORY = "repo_not_directory"
+    GITIGNORE_UNWRITABLE = "gitignore_unwritable"
+    PROMPT_CONTEXT_FAILED = "prompt_context_failed"
+    CLIPBOARD_UNAVAILABLE = "clipboard_unavailable"
+    HOOK_INSTALL_FAILED = "hook_install_failed"
+    HYGIENE_HOOKS_DEFERRED = "hygiene_hooks_deferred"
+    BASELINE_INVENTORY_MISSING = "baseline_inventory_missing"
+    WORKFLOW_CHANGE = "workflow_change"
+    UNSUPPORTED_RENAME_COPY = "unsupported_rename_copy"
+    DEPENDENCY_MANIFEST_UNCERTAIN = "dependency_manifest_uncertain"
+    COMMAND_MANIFEST_UNCERTAIN = "command_manifest_uncertain"
+    COMMAND_MANIFEST_MISSING = "command_manifest_missing"
+    COMMAND_CHECK_INCONCLUSIVE = "command_check_inconclusive"
+    DEPENDENCY_SCOPE_REVIEW = "dependency_scope_review"
+    JS_ALIAS_UNCERTAIN = "js_alias_uncertain"
+    EXECUTION_EVIDENCE_MISSING = "execution_evidence_missing"
+    EXECUTION_EVIDENCE_PRESENT = "execution_evidence_present"
+    EXECUTION_FAILED = "execution_failed"
+    EXECUTION_INCONCLUSIVE = "execution_inconclusive"
+
+
+_CANONICAL = {code.value for code in ReasonCode}
+_ALIASES = {
+    "baseline-corrupt": ReasonCode.BASELINE_CORRUPT.value,
+    "baseline-missing": ReasonCode.BASELINE_MISSING.value,
+    "baseline-stale": ReasonCode.BASELINE_STALE.value,
+}
+
+
+def normalize_reason_code(code: str) -> str:
+    normalized = str(code).strip().lower().replace("-", "_").replace(" ", "_")
+    normalized = _ALIASES.get(normalized, normalized)
+    return normalized
+
+
+def is_canonical_reason_code(code: str) -> bool:
+    return normalize_reason_code(code) in _CANONICAL
+
+
+def canonical_reason_codes() -> tuple[str, ...]:
+    return tuple(sorted(_CANONICAL))

sourcepack/reports/__init__.py

@@ -0,0 +1,5 @@
+from .html import render_report_html
+from .markdown import render_traffic
+from .json import normalized_finding, traffic_report, write_user_report
+
+__all__ = ["render_report_html", "render_traffic", "normalized_finding", "traffic_report", "write_user_report"]

sourcepack/reports/html.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from xml.sax.saxutils import escape as xml_escape
+
+
+def _html_escape(value: object) -> str:
+    return xml_escape("" if value is None else str(value), {'"': '"', "'": '''})
+
+
+def _report_badge_class(verdict: str) -> str:
+    return {"PASS": "pass", "WARN": "warn", "FAIL": "fail"}.get(verdict, "warn")
+
+def render_report_html(report: dict) -> str:
+    verdict = str(report.get("verdict", "WARN"))
+    badge = _report_badge_class(verdict)
+    findings = report.get("findings", []) if isinstance(report.get("findings"), list) else []
+    raw_json_path = report.get("report_path") or ".sourcepack/reports/latest.json"
+    baseline_path = report.get("baseline_packet_path") or (report.get("baseline") or {}).get("packet_path") if isinstance(report.get("baseline"), dict) else report.get("baseline_packet_path")
+
+    def finding_rows(items: list[dict]) -> str:
+        if not items:
+            return '<tr><td colspan="5" class="muted">None.</td></tr>'
+        rows = []
+        for f in items:
+            rows.append(
+                "<tr>"
+                f"<td><code>{_html_escape(f.get('id'))}</code></td>"
+                f"<td><span class='severity {_html_escape(f.get('severity'))}'>{_html_escape(f.get('severity'))}</span></td>"
+                f"<td>{_html_escape(f.get('path') or '—')}</td>"
+                f"<td>{_html_escape(f.get('message'))}</td>"
+                f"<td>{_html_escape(f.get('suggestion') or f.get('evidence') or '—')}</td>"
+                "</tr>"
+            )
+        return "\n".join(rows)
+
+    checked = "".join(f"<li>{_html_escape(item)}</li>" for item in report.get("checked_categories", [])) or "<li>None recorded.</li>"
+    not_checked = "".join(f"<li>{_html_escape(item)}</li>" for item in report.get("not_checked", [])) or "<li>None recorded.</li>"
+    affected = sorted({str(f.get("path")) for f in findings if f.get("path")})
+    affected_html = "".join(f"<li><code>{_html_escape(path)}</code></li>" for path in affected) or "<li>No affected file paths recorded.</li>"
+    missing = [f for f in findings if f.get("id") in {"missing_file", "unsupported_dependency", "unsupported_command", "unsupported_ecosystem", "js_alias_uncertain", "dependency_manifest_uncertain"} or f.get("category") == "uncertainty"]
+    fixes = [f for f in findings if f.get("suggestion")]
+    missing_html = "".join(f"<li><code>{_html_escape(f.get('id'))}</code>: {_html_escape(f.get('message'))}</li>" for f in missing) or "<li>No missing evidence recorded.</li>"
+    fixes_html = "".join(f"<li>{_html_escape(f.get('suggestion'))}</li>" for f in fixes) or "<li>No suggested fixes recorded.</li>"
+    generated = _html_escape(report.get("generated_at", "unknown"))
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SourcePack Report - {verdict}</title>
+<style>
+:root {{ color-scheme: light dark; --bg:#0f172a; --panel:#111827; --text:#e5e7eb; --muted:#94a3b8; --line:#334155; --pass:#16a34a; --warn:#d97706; --fail:#dc2626; }}
+body {{ margin:0; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background:var(--bg); color:var(--text); }}
+main {{ max-width:1100px; margin:0 auto; padding:32px 20px 56px; }}
+header, section {{ background:rgba(17,24,39,.92); border:1px solid var(--line); border-radius:18px; padding:22px; margin:16px 0; box-shadow:0 20px 50px rgba(0,0,0,.22); }}
+h1 {{ margin:0 0 8px; font-size:32px; }}
+h2 {{ margin-top:0; }}
+.badge {{ display:inline-block; padding:8px 14px; border-radius:999px; font-weight:800; letter-spacing:.04em; }}
+.badge.pass {{ background:var(--pass); }} .badge.warn {{ background:var(--warn); }} .badge.fail {{ background:var(--fail); }}
+.grid {{ display:grid; grid-template-columns:repeat(auto-fit,minmax(220px,1fr)); gap:14px; }}
+.card {{ border:1px solid var(--line); border-radius:14px; padding:14px; background:rgba(15,23,42,.72); }}
+.label {{ color:var(--muted); font-size:12px; text-transform:uppercase; letter-spacing:.08em; }}
+.value {{ margin-top:6px; font-weight:650; overflow-wrap:anywhere; }}
+table {{ width:100%; border-collapse:collapse; }} th, td {{ text-align:left; border-bottom:1px solid var(--line); padding:10px; vertical-align:top; }} th {{ color:var(--muted); font-size:13px; }}
+code {{ color:#bfdbfe; }} .muted {{ color:var(--muted); }} .severity.error {{ color:#fca5a5; }} .severity.warn {{ color:#fcd34d; }} .severity.info {{ color:#93c5fd; }}
+</style>
+</head>
+<body><main>
+<header>
+<span class="badge {badge}">{_html_escape(report.get('light') or verdict)}</span>
+<h1>SourcePack local report</h1>
+<p>{_html_escape(report.get('headline'))}</p>
+<p class="muted">Generated {generated}</p>
+</header>
+<section class="grid">
+<div class="card"><div class="label">Verdict</div><div class="value">{_html_escape(verdict)}</div></div>
+<div class="card"><div class="label">Reason type</div><div class="value">{_html_escape(report.get('reason_type') or 'none')}</div></div>
+<div class="card"><div class="label">Commit policy</div><div class="value">{_html_escape(report.get('commit_policy') or 'allowed.')}</div></div>
+<div class="card"><div class="label">Raw JSON</div><div class="value"><code>{_html_escape(raw_json_path)}</code></div></div>
+</section>
+<section><h2>Reason codes</h2><table><thead><tr><th>Code</th><th>Severity</th><th>Path</th><th>Explanation</th><th>Evidence / fix</th></tr></thead><tbody>{finding_rows(findings)}</tbody></table></section>
+<section class="grid"><div class="card"><h2>Affected files</h2><ul>{affected_html}</ul></div><div class="card"><h2>Evidence found</h2><ul>{checked}</ul></div><div class="card"><h2>Evidence missing</h2><ul>{missing_html}</ul></div><div class="card"><h2>Suggested fixes</h2><ul>{fixes_html}</ul></div></section>
+<section><h2>Baseline and prompt trust</h2><p>SourcePack treats prompt context as helpful but non-authoritative. Diff checks are judged against the trusted local baseline packet.</p><div class="grid"><div class="card"><div class="label">Baseline state</div><div class="value">{_html_escape(report.get('baseline_state') or 'not recorded')}</div></div><div class="card"><div class="label">Baseline packet</div><div class="value"><code>{_html_escape(baseline_path or 'not recorded')}</code></div></div></div></section>
+<section class="grid"><div class="card"><h2>Checked</h2><ul>{checked}</ul></div><div class="card"><h2>Not checked</h2><ul>{not_checked}</ul></div></section>
+<section><h2>Execution evidence</h2><p>Execution evidence proves only that a command was run locally and records exit/output hashes; it does not prove correctness, security, or external API behavior.</p></section><section><h2>Safe next actions</h2><p>{_html_escape(report.get('next_action'))}</p></section>
+</main></body></html>"""
+
+

sourcepack/reports/json.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from sourcepack import __version__
+from sourcepack.paths import ensure_sourcepack_dirs
+from sourcepack.reports.html import render_report_html
+from sourcepack.reports.markdown import LIGHT_BY_VERDICT, render_traffic
+from sourcepack.reason_codes import normalize_reason_code, is_canonical_reason_code
+from sourcepack.evidence import attach_evidence_to_finding, evidence_summary, make_evidence
+
+SEVERITY_ORDER = {"error": 0, "warn": 1, "info": 2}
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+def normalized_finding(fid: str, severity: str, category: str, message: str, path: str | None = None, evidence: str | None = None, suggestion: str | None = None) -> dict:
+    code = normalize_reason_code(fid)
+    if severity in {"error", "warn"} and not is_canonical_reason_code(code):
+        raise ValueError(f"unknown SourcePack reason code: {fid}")
+    return {"id": code, "severity": severity, "category": category, "path": path, "message": message, "evidence": evidence, "suggestion": suggestion}
+
+
+def normalize_finding_evidence(finding: dict) -> dict:
+    if finding.get("evidence_class"):
+        return finding
+    fid = str(finding.get("id") or "")
+    category = str(finding.get("category") or "")
+    source = str(finding.get("evidence") or finding.get("path") or category or fid)
+    if category == "dependency" or fid in {"unsupported_dependency", "declared_dependency", "dependency_scope_review"}:
+        status = "missing" if fid == "unsupported_dependency" else "partially_checked" if fid in {"declared_dependency", "dependency_scope_review"} else "checked"
+        return attach_evidence_to_finding(finding, "dependency_manifest", source, status, missing_evidence=source if status == "missing" else None, required_evidence_class="dependency_manifest")
+    if category == "command" or fid in {"unsupported_command", "declared_command", "command_manifest_missing", "command_check_inconclusive", "command_manifest_uncertain"}:
+        status = "missing" if fid in {"unsupported_command", "command_manifest_missing"} else "partially_checked" if fid in {"declared_command", "command_check_inconclusive", "command_manifest_uncertain"} else "checked"
+        return attach_evidence_to_finding(finding, "command_manifest", source, status, missing_evidence=source if status == "missing" else None, required_evidence_class="command_manifest")
+    if category == "execution" or fid.startswith("execution_"):
+        status = "checked" if fid == "execution_evidence_present" else "unavailable" if fid == "execution_evidence_missing" else "partially_checked"
+        return attach_evidence_to_finding(finding, "execution_ledger", source, status, missing_evidence=source if status == "unavailable" else None, required_evidence_class="execution_ledger", supports_claim="local_execution")
+    if category in {"baseline", "file"} or fid in {"missing_file", "baseline_missing", "baseline_corrupt", "baseline_stale", "baseline_inventory_missing"}:
+        status = "missing" if fid in {"missing_file", "baseline_missing", "baseline_corrupt", "baseline_inventory_missing"} else "checked"
+        return attach_evidence_to_finding(finding, "trusted_baseline", source, status, missing_evidence=source if status == "missing" else None, required_evidence_class="trusted_baseline")
+    if category == "artifact" or fid in {"protected_artifact", "git_path_modification"}:
+        eclass = "git_metadata" if fid == "git_path_modification" else "trusted_baseline"
+        return attach_evidence_to_finding(finding, eclass, source, "checked", required_evidence_class=eclass)
+    if fid in {"unsupported_ecosystem", "binary_diff", "path_escape", "unsafe_path"}:
+        return attach_evidence_to_finding(finding, "unsupported", source, "unsupported", missing_evidence=source, required_evidence_class="current_worktree")
+    return finding
+
+
+def traffic_report(verdict: str, headline: str | None = None, findings: list[dict] | None = None, checked_categories: list[str] | None = None, next_action: str | None = None, report_path: str = ".sourcepack/reports/latest.json", reason_type: str | None = None, not_checked: list[str] | None = None) -> dict:
+    findings = [normalize_finding_evidence(f) for f in (findings or [])]
+    findings = sorted(findings, key=lambda f: (SEVERITY_ORDER.get(f.get("severity", "info"), 9), f.get("id", ""), f.get("path") or ""))
+    blockers = [f for f in findings if f.get("severity") == "error"]
+    warnings = [f for f in findings if f.get("severity") == "warn"]
+    light = LIGHT_BY_VERDICT.get(verdict, "YELLOW LIGHT")
+    if reason_type is None:
+        reason_type = "blocker" if verdict == "FAIL" else "review" if warnings else "none"
+        if any(f.get("category") in {"uncertainty", "tooling"} for f in warnings):
+            reason_type = "uncertainty" if any(f.get("category") == "uncertainty" for f in warnings) else "tooling"
+    if headline is None:
+        if verdict == "WARN" and reason_type == "uncertainty":
+            headline = "SourcePack could not fully evaluate this change."
+        elif verdict == "WARN" and reason_type == "tooling":
+            headline = "SourcePack tooling degraded."
+        else:
+            headline = {"PASS": "good to continue.", "WARN": "review before continuing.", "FAIL": "stop before trusting this output."}.get(verdict, "review before continuing.")
+    next_action = next_action or ("ask the AI to revise using only files, dependencies, and commands confirmed by SourcePack." if verdict == "FAIL" else "review the listed items before continuing." if verdict == "WARN" else "continue.")
+    commit_policy = None
+    if verdict == "WARN":
+        commit_policy = "allowed locally, blocked in strict mode."
+    elif verdict == "FAIL":
+        commit_policy = "blocked unless explicitly bypassed."
+    checked_categories = checked_categories or []
+    not_checked = not_checked or ["runtime behavior", "semantic correctness", "security", "external services"]
+    records = []
+    for category in checked_categories:
+        eclass = "trusted_baseline" if "baseline" in category else "dependency_manifest" if "import" in category.lower() else "command_manifest" if "command" in category.lower() else "current_worktree"
+        records.append(make_evidence(eclass, category, "checked"))
+    for category in not_checked:
+        records.append(make_evidence("not_checked", category, "not_checked"))
+    for f in findings:
+        if f.get("evidence_class"):
+            records.append(f)
+    evidence = evidence_summary(records)
+    partial = sorted({f["category"] for f in findings if f.get("checked_status") == "partially_checked"} | ({"execution_claim_check"} if any(f.get("category") == "execution" for f in findings) else set()))
+    checked_names = sorted(set(checked_categories) | {f["category"] for f in findings if f.get("checked_status") == "checked"})
+    confidence_summary = {"basis": "local evidence coverage, not AI confidence", "checked": checked_names, "partially_checked": partial, "not_checked": not_checked, "limitations": ["SourcePack does not prove code correctness", "SourcePack does not prove security", "SourcePack does not verify external API behavior unless local evidence exists"]}
+    return {"schema_version": "traffic_report.v1", "sourcepack_version": __version__, "verdict": verdict, "light": light, "headline": headline, "reason_type": reason_type, "commit_policy": commit_policy, "blockers": blockers, "warnings": warnings, "uncertainties": [f for f in warnings if f.get("category") == "uncertainty"], "checked_categories": checked_names, "checked": checked_names, "partially_checked": partial, "unavailable_evidence": evidence["missing_evidence"], "unsupported_evidence": [f for f in findings if f.get("id") == "unsupported_ecosystem"], "not_checked": not_checked, "confidence_summary": confidence_summary, "evidence": evidence, "next_action": next_action, "report_path": report_path, "findings": findings}
+
+
+def _write_optional_report_file(path: Path, content: str) -> None:
+    try:
+        path.write_text(content, encoding="utf-8")
+    except Exception as exc:
+        print(f"WARNING: could not write SourcePack report artifact {path}: {exc}", file=sys.stderr)
+
+
+def write_user_report(repo: str | Path, report: dict, stem: str = "report") -> None:
+    paths = ensure_sourcepack_dirs(repo)
+    full = dict(report)
+    full.setdefault("sourcepack_version", __version__)
+    full.setdefault("schema_version", "traffic_report.v1")
+    full["generated_at"] = utc_now()
+    json_text = json.dumps(full, indent=2)
+    md_text = render_traffic(full, verbose=True)
+    paths["latest_json"].write_text(json_text, encoding="utf-8")
+    _write_optional_report_file(paths["latest_md"], md_text)
+    try:
+        html_text = render_report_html(full)
+    except Exception as exc:
+        print(f"WARNING: could not render SourcePack HTML report: {exc}", file=sys.stderr)
+    else:
+        _write_optional_report_file(paths["latest_html"], html_text)
+    typed = paths.get(f"latest_{stem}_json")
+    if typed is not None:
+        _write_optional_report_file(typed, json_text)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    _write_optional_report_file(paths["archive"] / f"{ts}_{stem}.json", json_text)
+    _write_optional_report_file(paths["archive"] / f"{ts}_{stem}.md", md_text)

sourcepack/reports/markdown.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+LIGHT_BY_VERDICT = {"PASS": "GREEN LIGHT", "WARN": "YELLOW LIGHT", "FAIL": "RED LIGHT"}
+SEVERITY_ORDER = {"error": 0, "warn": 1, "info": 2}
+
+def render_traffic(report: dict, verbose: bool = False) -> str:
+    verdict = report.get("verdict", "WARN")
+    lines = [f"Verdict: {verdict}", f"{report.get('light', LIGHT_BY_VERDICT.get(verdict, 'YELLOW LIGHT'))}: {report.get('headline', '')}", ""]
+    if report.get("reason_type"):
+        lines.append(f"Reason type: {report.get('reason_type')}")
+    lines.append(f"Commit policy: {report.get('commit_policy') or 'allowed.'}")
+    lines.append("")
+    if verdict == "PASS":
+        info = [f for f in report.get("findings", []) if f.get("severity") == "info"]
+        lines.append(info[0]["message"] if info else "No unsupported project claims or patch assumptions detected.")
+        if report.get("checked_categories"):
+            lines.extend(["", "Checked:", ""])
+            lines.extend(f"- {item}" for item in report.get("checked_categories", []))
+        if report.get("not_checked"):
+            lines.extend(["", "Not checked:", ""])
+            lines.extend(f"- {item}" for item in report.get("not_checked", []))
+    elif verdict == "WARN":
+        lines.append("SourcePack found review or uncertainty items, but no clear unsupported blocker.")
+        review = [f for f in report.get("warnings", []) if f.get("category") != "uncertainty"]
+        uncertain = [f for f in report.get("warnings", []) if f.get("category") == "uncertainty"]
+        if review:
+            lines.extend(["", "Review warnings:", ""])
+            shown = review if verbose else review[:3]
+            lines.extend(f"- {f.get('id')}: {f.get('message')}" for f in shown)
+        if uncertain:
+            lines.extend(["", "Uncertainties:", ""])
+            shown = uncertain if verbose else uncertain[:3]
+            lines.extend(f"- {f.get('id')}: {f.get('message')}" for f in shown)
+        lines.extend(["", f"Next action: {report.get('next_action')}"])
+    else:
+        lines.append("SourcePack found missing files, unsupported dependencies, unsupported commands, or unsupported capabilities.")
+        if report.get("blockers"):
+            lines.extend(["", "Blockers:", ""])
+            shown = report.get("blockers", []) if verbose else report.get("blockers", [])[:3]
+            lines.extend(f"- {f.get('id')}: {f.get('message')}" for f in shown)
+        review = [f for f in report.get("warnings", []) if f.get("category") != "uncertainty"]
+        uncertain = [f for f in report.get("warnings", []) if f.get("category") == "uncertainty"]
+        if review:
+            lines.extend(["", "Review warnings:", ""])
+            shown = review if verbose else review[:3]
+            lines.extend(f"- {f.get('id')}: {f.get('message')}" for f in shown)
+        if uncertain:
+            lines.extend(["", "Uncertainties:", ""])
+            shown = uncertain if verbose else uncertain[:3]
+            lines.extend(f"- {f.get('id')}: {f.get('message')}" for f in shown)
+        lines.extend(["", f"Next action: {report.get('next_action')}"])
+    if verdict != "PASS":
+        if report.get("checked_categories"):
+            lines.extend(["", "Checked:", ""])
+            lines.extend(f"- {item}" for item in report.get("checked_categories", []))
+        if report.get("not_checked"):
+            lines.extend(["", "Not checked:", ""])
+            lines.extend(f"- {item}" for item in report.get("not_checked", []))
+    lines.extend(["", f"Report path: {report.get('report_path', '.sourcepack/reports/latest.json')}"])
+    return "\n".join(lines) + "\n"
+

sourcepack/schemas.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+from .reason_codes import ReasonCode
+
+BASELINE_SCHEMA_VERSION = "baseline_pointer.v1"
+JUDGMENT_REPORT_SCHEMA_VERSION = "traffic_report.v1"
+PROMPT_CONTEXT_SCHEMA_VERSION = "prompt_context.v1"
+
+
+class Verdict(StrEnum):
+    PASS = "PASS"
+    WARN = "WARN"
+    FAIL = "FAIL"
+
+
+class Severity(StrEnum):
+    INFO = "info"
+    WARN = "warn"
+    ERROR = "error"
+
+
+class PolicyMode(StrEnum):
+    LOCAL = "local"
+    STRICT = "strict"
+    CI = "ci"
+
+
+@dataclass(frozen=True)
+class Finding:
+    code: ReasonCode | str
+    severity: Severity | str
+    path: str | None
+    message: str
+    evidence: str | None = None
+    suggested_fixes: list[str] = field(default_factory=list)
+    category: str | None = None
+
+    def to_report_dict(self) -> dict[str, Any]:
+        suggestion = self.suggested_fixes[0] if self.suggested_fixes else None
+        return {
+            "id": str(self.code),
+            "severity": str(self.severity),
+            "category": self.category,
+            "path": self.path,
+            "message": self.message,
+            "evidence": self.evidence,
+            "suggestion": suggestion,
+        }
+
+
+@dataclass(frozen=True)
+class Judgment:
+    verdict: Verdict | str
+    findings: list[Finding]
+    checked_categories: list[str]
+    not_checked: list[str]
+    reason_type: str | None
+    commit_policy: str | None
+    next_action: str