docassert 0.12.1__tar.gz → 0.14.0__tar.gz

{docassert-0.12.1/docassert.egg-info → docassert-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.12.1
+Version: 0.14.0
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0

{docassert-0.12.1 → docassert-0.14.0}/docassert/__init__.py

@@ -5,4 +5,4 @@ standard: deterministic structural checks that gate a merge, plus optional
 AI-graded semantic checks that advise.
 """
 
-__version__ = "0.12.1"
+__version__ = "0.14.0"

{docassert-0.12.1 → docassert-0.14.0}/docassert/_data/schema/project.schema.json

@@ -7,6 +7,11 @@
   "additionalProperties": true,
   "properties": {
     "kind": { "const": "project" },
+    "repo": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$",
+      "description": "Optional OWNER/NAME of the code repository this project's execution bridge targets."
+    },
     "id": {
       "type": "string",
       "pattern": "^PRJ-\\d{3,}-[A-Z]{2,6}$",

{docassert-0.12.1 → docassert-0.14.0}/docassert/bridge/plan.py

@@ -83,7 +83,8 @@ def _anchors(documents_dir: Path) -> dict[str, dict]:
             continue
         if doc.kind == "project" and doc.id:
             out[doc.id] = {"code": str(doc.frontmatter.get("code", "")),
-                           "name": str(doc.frontmatter.get("name", ""))}
+                           "name": str(doc.frontmatter.get("name", "")),
+                           "repo": str(doc.frontmatter.get("repo", "") or "")}
     return out
 
 
@@ -155,10 +156,41 @@ def build_bridge_plan(documents_dir: str | Path = "documents") -> BridgePlan:
                                  "reason": "; ".join(problems)})
             continue
         plan.projects.append({"id": proj_id, "code": code, "name": meta["name"],
+                              "repo": meta.get("repo", ""),
                               "features": list(features.values())})
     return plan
 
 
+def filter_plan(plan: BridgePlan, project: str) -> BridgePlan:
+    """A plan reduced to one project (matched by id or code). Unknown ids
+    yield an empty plan whose skipped list explains why."""
+    key = project.strip()
+    keep = [p for p in plan.projects
+            if p["id"] == key or p["code"] == key]
+    out = BridgePlan(projects=keep,
+                     skipped=[s for s in plan.skipped if s["id"] == key])
+    if not keep and not out.skipped:
+        out.skipped.append({"id": key, "reason": "no such project in the plan"})
+    return out
+
+
+def plans_by_repo(plan: BridgePlan) -> dict[str, BridgePlan]:
+    """Group a plan by each project's mapped repository (the `repo` field on
+    the project anchor). Projects sharing a repo share one sub-plan, so
+    reconciliation in that repo sees the union of their managed ids.
+    Raises ValueError naming any project without a mapping."""
+    unmapped = [p["id"] for p in plan.projects if not p.get("repo")]
+    if unmapped:
+        raise ValueError(
+            "no repo mapping on project anchor(s): " + ", ".join(unmapped)
+            + " (add `repo: OWNER/NAME` to project.md or pass --repo)")
+    groups: dict[str, BridgePlan] = {}
+    for proj in plan.projects:
+        groups.setdefault(proj["repo"],
+                          BridgePlan(skipped=plan.skipped)).projects.append(proj)
+    return groups
+
+
 def feature_title(f: Feature) -> str:
     return f"[{f.id}] {_title(f.text)}"
 

{docassert-0.12.1 → docassert-0.14.0}/docassert/cli.py

@@ -238,7 +238,7 @@ def cmd_pages(args: argparse.Namespace) -> int:
         data = _json.loads(Path(args.execution).read_text())
         for proj in data.get("projects", []):
             execution[proj["id"]] = {**proj, "scope": data.get("scope"),
-                                     "repo": data.get("repo")}
+                                     "repo": proj.get("repo") or data.get("repo")}
 
     plist = projects_mod.load_projects(docs_dir)
     for p in plist:
@@ -306,10 +306,30 @@ def cmd_bridge(args: argparse.Namespace) -> int:
     Scope flows documents -> GitHub only; the bridge never edits documents."""
     from .bridge import build_bridge_plan, ops
     from .bridge import gh as ghmod
+    from .bridge.plan import filter_plan, plans_by_repo
 
     plan = build_bridge_plan(args.documents_dir)
+    if getattr(args, "project", None):
+        plan = filter_plan(plan, args.project)
     gh = ghmod.DryRunner() if getattr(args, "dry_run", False) else ghmod.GhRunner()
 
+    # Repo resolution: an explicit --repo applies the whole plan to one
+    # repository (single-repo portfolios, back-compatible); without it, each
+    # project routes to the repo mapped on its anchor.
+    if args.action != "create-board":
+        if args.repo:
+            repo_plans = {args.repo: plan}
+        else:
+            try:
+                repo_plans = plans_by_repo(plan)
+            except ValueError as exc:
+                print(f"docassert bridge: {exc}", file=sys.stderr)
+                return 2
+            if not repo_plans and plan.skipped:
+                for s in plan.skipped:
+                    print(f"docassert bridge: skipped {s['id']}: {s['reason']}")
+                return 0
+
     if args.action == "create-board":
         from .bridge import board as board_mod
         token = os.environ.get(args.board_token_env, "")
@@ -329,30 +349,46 @@ def cmd_bridge(args: argparse.Namespace) -> int:
                   "(needed for --project-number)", file=sys.stderr)
             return 2
         bgh = gh if isinstance(gh, ghmod.DryRunner) else ghmod.GhRunner(token=token)
-        board_cfg = {"gh": bgh, "owner": args.project_owner or args.repo.split("/")[0],
+        owner = args.project_owner or next(iter(repo_plans)).split("/")[0]
+        board_cfg = {"gh": bgh, "owner": owner,
                      "number": args.project_number, "init": args.init_board}
 
     if args.action == "scaffold":
-        actions = ops.scaffold(plan, gh, args.repo, docs_url=args.docs_url,
-                               board_cfg=board_cfg)
-        for a in actions:
-            print(f"docassert bridge: {a}")
+        for repo, sub in repo_plans.items():
+            actions = ops.scaffold(sub, gh, repo, docs_url=args.docs_url,
+                                   board_cfg=board_cfg)
+            for a in actions:
+                print(f"docassert bridge: [{repo}] {a}")
         if isinstance(gh, ghmod.DryRunner):
             print(f"docassert bridge: dry run — {len(gh.planned)} mutation(s) planned")
             for m in gh.planned:
                 print(f"  {m}")
         return 0
     if args.action == "reconcile":
-        lines, code = ops.reconcile(plan, gh, args.repo)
-        for line in lines:
-            print(f"docassert bridge: {line}")
-        return code
+        worst = 0
+        for repo, sub in repo_plans.items():
+            lines, code = ops.reconcile(sub, gh, repo)
+            for line in lines:
+                print(f"docassert bridge: [{repo}] {line}")
+            worst = max(worst, code)
+        return worst
     if args.action == "status":
-        data = ops.status(plan, gh, args.repo)
-        sys.stdout.write(ops.to_json(data) if args.json else
-                         ops.render_status(data) + "\n")
+        merged: dict = {"repo": None, "projects": [], "scope": {"unverified": [], "orphaned": []}}
+        for repo, sub in repo_plans.items():
+            data = ops.status(sub, gh, repo)
+            for proj in data.get("projects", []):
+                proj["repo"] = repo
+                merged["projects"].append(proj)
+            for key in ("unverified", "orphaned"):
+                for item in data.get("scope", {}).get(key, []):
+                    item["repo"] = repo
+                    merged["scope"][key].append(item)
+        if len(repo_plans) == 1:
+            merged["repo"] = next(iter(repo_plans))
+        sys.stdout.write(ops.to_json(merged) if args.json else
+                         ops.render_status(merged) + "\n")
         if args.json and args.out:
-            Path(args.out).write_text(ops.to_json(data))
+            Path(args.out).write_text(ops.to_json(merged))
         return 0
     print(f"docassert bridge: unknown action {args.action!r}", file=sys.stderr)
     return 2
@@ -441,7 +477,9 @@ def main(argv: list[str] | None = None) -> int:
     b = sub.add_parser("bridge", help="Execution bridge: scaffold and police the GitHub board from approved stories.")
     b.add_argument("action", choices=["scaffold", "reconcile", "status", "create-board"],
                    help="scaffold: docs -> issues/board · reconcile: police the board · status: delivery figures.")
-    b.add_argument("--repo", required=True, help="Target GitHub repo (OWNER/NAME) holding the issues.")
+    b.add_argument("--repo", help="Target GitHub repo (OWNER/NAME) for the whole plan; "
+                   "omit to route each project to the `repo:` on its anchor.")
+    b.add_argument("--project", help="Scope to one project (PRJ-NNN-CODE id or CODE).")
     b.add_argument("--docs-url", help="Base URL of the documents repo, for source links in issue bodies.")
     b.add_argument("--dry-run", action="store_true", help="Print planned mutations without executing them.")
     b.add_argument("--json", action="store_true", help="status: emit JSON.")

{docassert-0.12.1 → docassert-0.14.0}/docassert/status/derive.py

@@ -5,6 +5,7 @@ lives in docassert.status.render.
 """
 from __future__ import annotations
 
+import re
 from pathlib import Path
 
 from .. import config as config_mod
@@ -63,6 +64,10 @@ def _coverage(graph, config, code=None):
     return out
 
 
+_RISK_FIELD_RE = re.compile(
+    r"\s*(?:Probability|Impact|Owner|Response)\s*:", re.IGNORECASE)
+
+
 def _risks(graph, code=None):
     risks = []
     for item in graph.by_type.get("RISK", []):
@@ -70,11 +75,21 @@ def _risks(graph, code=None):
             continue
         prob = (_field_value(item.text, "probability") or "").lower()
         impact = (_field_value(item.text, "impact") or "").lower()
+        # The description is the item text up to the first metadata field;
+        # the response runs from its label to the end (it may hold clauses
+        # that _field_value would truncate at a sentence break).
+        m = _RISK_FIELD_RE.search(item.text)
+        description = (item.text[:m.start()] if m else item.text).strip()
+        rm = re.search(r"Response\s*:\s*(.+)$", item.text,
+                       re.IGNORECASE | re.DOTALL)
         risks.append({
             "id": item.id,
+            "description": description,
+            "threatens": item.links.get("threatens", []),
             "probability": prob or "?",
             "impact": impact or "?",
             "owner": _field_value(item.text, "owner") or "?",
+            "response": rm.group(1).strip() if rm else "",
             "score": _SEVERITY.get(prob, 0) * _SEVERITY.get(impact, 0),
         })
     return sorted(risks, key=lambda r: -r["score"])

{docassert-0.12.1 → docassert-0.14.0}/docassert/status/render.py

@@ -143,9 +143,27 @@ def render_html(model) -> str:
         + (";background:var(--amber)" if cov["gaps"] else "") + '"></div></div></div>'
         for cov in model["coverage"])
 
-    risks = "".join(
-        f'<li><code>{esc(r["id"])}</code> — {esc(r["probability"])}/{esc(r["impact"])}'
-        f' · owner {esc(r["owner"])}</li>' for r in model["risks"]) or "<li>None open.</li>"
+    def sev(value):
+        color = {"critical": "var(--bad)", "high": "var(--bad)",
+                 "medium": "var(--amber)", "low": "var(--ok)"}.get(
+                     value, "var(--muted)")
+        return f'<td style="color:{color};font-weight:600;">{esc(value)}</td>'
+
+    if model["risks"]:
+        risk_rows = "".join(
+            f'<tr><td><code>{esc(r["id"])}</code></td>'
+            f'<td>{esc(r["description"])}</td>'
+            f'<td>{", ".join(f"<code>{esc(b)}</code>" for b in r["threatens"]) or "—"}</td>'
+            + sev(r["probability"]) + sev(r["impact"])
+            + f'<td>{esc(r["owner"])}</td>'
+            f'<td>{esc(r["response"]) or "—"}</td></tr>'
+            for r in model["risks"])
+        risks = ('<table><thead><tr><th>ID</th><th>Risk</th><th>Threatens</th>'
+                 '<th>Probability</th><th>Impact</th><th>Owner</th>'
+                 '<th>Response</th></tr></thead>'
+                 f'<tbody>{risk_rows}</tbody></table>')
+    else:
+        risks = "<p>None open.</p>"
 
     problems = ""
     if model["broken_references"]:
@@ -230,7 +248,7 @@ def render_html(model) -> str:
         bad = scope.get("unverified", []) + scope.get("orphaned", [])
         if bad:
             items = "".join(
-                f'<li><a href="https://github.com/{esc(ex.get("repo", ""))}/issues/{i["number"]}">#{i["number"]}</a> {esc(i["title"])}</li>'
+                f'<li><a href="https://github.com/{esc(i.get("repo") or ex.get("repo") or "")}/issues/{i["number"]}">#{i["number"]}</a> {esc(i["title"])}</li>'
                 for i in bad)
             execution_html += (
                 f'<section><h2 style="color:var(--bad)">Scope · {len(bad)} unmatched item(s)</h2>'
@@ -262,7 +280,7 @@ def render_html(model) -> str:
   {document_set}
   {execution_html}
   {problems}
-  <section><h2>Open risks ({len(model['risks'])})</h2><ul>{risks}</ul></section>
+  <section><h2>Open risks ({len(model['risks'])})</h2>{risks}</section>
   <section><h2>Latest status report</h2><p>{report}</p></section>
   <section><h2>Documents ({c['total']})</h2>
     <table><thead><tr><th>Kind</th><th>ID</th><th>Status</th><th>Audit</th></tr></thead>

{docassert-0.12.1 → docassert-0.14.0/docassert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.12.1
+Version: 0.14.0
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0

{docassert-0.12.1 → docassert-0.14.0}/tests/test_bridge.py

@@ -349,3 +349,95 @@ def test_status_includes_scope_classification(tmp_path):
     assert data["repo"] == "o/r"
     assert [i["number"] for i in data["scope"]["unverified"]] == [2]
     assert [i["doc"] for i in data["scope"]["orphaned"]] == ["TST-US-999"]
+
+
+# ── project filter and per-repo mapping (ENG-US-001 / ENG-US-002) ────────────
+from docassert.bridge.plan import filter_plan, plans_by_repo  # noqa: E402
+
+ANCHOR2 = """---
+kind: project
+id: PRJ-002-TWO
+code: TWO
+name: Second Project
+sponsor: S
+status: active
+repo: owner/two-repo
+---
+
+## Overview
+
+x
+
+## Scope
+
+x
+"""
+
+PRD2 = PRD.replace("PRJ-001-TST", "PRJ-002-TWO").replace("TST", "TWO")
+STORIES2 = STORIES.replace("PRJ-001-TST", "PRJ-002-TWO").replace("TST", "TWO")
+
+
+def _two_project_tree(tmp_path, repo_one="owner/one-repo"):
+    docs = _tree(tmp_path)
+    if repo_one:
+        anchor = docs / "PRJ-001-TST" / "project.md"
+        anchor.write_text(anchor.read_text().replace(
+            "status: active", f"status: active\nrepo: {repo_one}"), encoding="utf-8")
+    d = docs / "PRJ-002-TWO"
+    d.mkdir()
+    (d / "project.md").write_text(ANCHOR2, encoding="utf-8")
+    (d / "prd.md").write_text(PRD2, encoding="utf-8")
+    (d / "user-story.md").write_text(STORIES2.format(status="approved"), encoding="utf-8")
+    return docs
+
+
+def test_filter_plan_by_id_and_code(tmp_path):
+    plan = build_bridge_plan(_two_project_tree(tmp_path))
+    assert len(plan.projects) == 2
+    only = filter_plan(plan, "PRJ-002-TWO")
+    assert [p["id"] for p in only.projects] == ["PRJ-002-TWO"]
+    by_code = filter_plan(plan, "TST")
+    assert [p["code"] for p in by_code.projects] == ["TST"]
+    missing = filter_plan(plan, "PRJ-999-NOPE")
+    assert not missing.projects and missing.skipped
+
+
+def test_plans_by_repo_routes_each_project(tmp_path):
+    plan = build_bridge_plan(_two_project_tree(tmp_path))
+    groups = plans_by_repo(plan)
+    assert set(groups) == {"owner/one-repo", "owner/two-repo"}
+    assert [p["id"] for p in groups["owner/one-repo"].projects] == ["PRJ-001-TST"]
+    assert [p["id"] for p in groups["owner/two-repo"].projects] == ["PRJ-002-TWO"]
+
+
+def test_plans_by_repo_shares_a_repo_as_a_union(tmp_path):
+    docs = _two_project_tree(tmp_path)
+    anchor = docs / "PRJ-002-TWO" / "project.md"
+    anchor.write_text(anchor.read_text().replace("owner/two-repo", "owner/one-repo"),
+                      encoding="utf-8")
+    plan = build_bridge_plan(docs)
+    groups = plans_by_repo(plan)
+    assert set(groups) == {"owner/one-repo"}
+    union = groups["owner/one-repo"]
+    assert len(union.projects) == 2
+    # both projects' ids are managed, so neither would be orphaned in reconcile
+    assert any(i.startswith("TST-") for i in union.managed_ids)
+    assert any(i.startswith("TWO-") for i in union.managed_ids)
+
+
+def test_plans_by_repo_names_unmapped_projects(tmp_path):
+    plan = build_bridge_plan(_two_project_tree(tmp_path, repo_one=None))
+    try:
+        plans_by_repo(plan)
+        raise AssertionError("expected ValueError")
+    except ValueError as exc:
+        assert "PRJ-001-TST" in str(exc) and "--repo" in str(exc)
+
+
+def test_anchor_without_repo_keeps_single_repo_mode_working(tmp_path):
+    # the original single-repo path: no repo fields, explicit --repo, unchanged
+    plan = build_bridge_plan(_tree(tmp_path))
+    assert plan.projects[0].get("repo", "") == ""
+    gh = FakeGh()
+    ops.scaffold(plan, gh, "o/r", docs_url=None)
+    assert any("issues" in " ".join(c) for c in gh.calls)

{docassert-0.12.1 → docassert-0.14.0}/tests/test_status.py

@@ -129,3 +129,36 @@ def test_render_project_page_has_back_link_and_scoped_title():
     assert 'href="index.html"' in out          # back to the portfolio index
     assert "Atlas" in out and "AMBER" in out
     assert "http://" not in out and "https://" not in out
+
+
+# ── the risk model carries the full story ────────────────────────────────────
+def test_risks_carry_description_threatens_and_response():
+    _cd_root()
+    m = S.build_status(ROOT / "documents")
+    r = next(r for r in m["risks"] if r["id"] == "AUR-RISK-001")
+    assert r["description"] and "Probability" not in r["description"]
+    assert r["threatens"]                     # links to the BRs at stake
+    assert r["response"]                      # the full mitigation text
+    assert r["probability"] in {"low", "medium", "high", "critical", "?"}
+
+
+def test_risks_tolerate_missing_fields():
+    from docassert.graph import Graph
+    from docassert.models import Item
+    from docassert.status.derive import _risks
+    g = Graph()
+    g.add(Item("XX-RISK-001", "XX", "RISK", "Bare risk with no fields yet.",
+               {}, "d.md", "risk-register", "draft", "S"))
+    (r,) = _risks(g)
+    assert r["description"] == "Bare risk with no fields yet."
+    assert r["response"] == "" and r["probability"] == "?"
+
+
+def test_render_html_risk_table():
+    _cd_root()
+    out = S.render_html(S.build_status(ROOT / "documents"))
+    assert "<th>Risk</th>" in out and "<th>Response</th>" in out
+    assert "<th>Threatens</th>" in out and "<th>Owner</th>" in out
+    # severity cells are colored
+    assert 'style="color:var(--bad);font-weight:600;">high</td>' in out \
+        or 'style="color:var(--amber);font-weight:600;">medium</td>' in out