PyPI - forge-doctor-api - Versions diffs - 0.2.0__py3-none-any.whl - Mend

forge-doctor-api 0.2.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (268) hide show

forge_doctor_api/__init__.py +69 -0
forge_doctor_api/__main__.py +3 -0
forge_doctor_api/_graphstudio.py +376 -0
forge_doctor_api/_graphview.py +181 -0
forge_doctor_api/analyzers/__init__.py +0 -0
forge_doctor_api/analyzers/asyncapi/__init__.py +39 -0
forge_doctor_api/analyzers/asyncapi/compat.py +274 -0
forge_doctor_api/analyzers/asyncapi/graph.py +116 -0
forge_doctor_api/analyzers/asyncapi/knowledge.py +60 -0
forge_doctor_api/analyzers/asyncapi/model.py +143 -0
forge_doctor_api/analyzers/asyncapi/parser.py +512 -0
forge_doctor_api/analyzers/cache/__init__.py +17 -0
forge_doctor_api/analyzers/cache/graph.py +256 -0
forge_doctor_api/analyzers/cache/model.py +66 -0
forge_doctor_api/analyzers/cache/scan.py +192 -0
forge_doctor_api/analyzers/clients/__init__.py +19 -0
forge_doctor_api/analyzers/clients/graph.py +57 -0
forge_doctor_api/analyzers/clients/graphql_doc.py +105 -0
forge_doctor_api/analyzers/clients/java.py +139 -0
forge_doctor_api/analyzers/clients/javascript.py +214 -0
forge_doctor_api/analyzers/clients/model.py +83 -0
forge_doctor_api/analyzers/clients/python.py +337 -0
forge_doctor_api/analyzers/clients/scan.py +72 -0
forge_doctor_api/analyzers/gateway/__init__.py +25 -0
forge_doctor_api/analyzers/gateway/model.py +128 -0
forge_doctor_api/analyzers/gateway/parser.py +572 -0
forge_doctor_api/analyzers/graphql/__init__.py +49 -0
forge_doctor_api/analyzers/graphql/client.py +164 -0
forge_doctor_api/analyzers/graphql/compat.py +228 -0
forge_doctor_api/analyzers/graphql/graph.py +105 -0
forge_doctor_api/analyzers/graphql/model.py +180 -0
forge_doctor_api/analyzers/graphql/parser.py +423 -0
forge_doctor_api/analyzers/graphql/shape.py +149 -0
forge_doctor_api/analyzers/grpc/__init__.py +51 -0
forge_doctor_api/analyzers/grpc/compat.py +288 -0
forge_doctor_api/analyzers/grpc/graph.py +84 -0
forge_doctor_api/analyzers/grpc/model.py +150 -0
forge_doctor_api/analyzers/grpc/parser.py +406 -0
forge_doctor_api/analyzers/grpc/reliability.py +130 -0
forge_doctor_api/analyzers/iac/__init__.py +21 -0
forge_doctor_api/analyzers/iac/cloudformation.py +152 -0
forge_doctor_api/analyzers/iac/graph.py +65 -0
forge_doctor_api/analyzers/iac/hcl.py +184 -0
forge_doctor_api/analyzers/iac/model.py +81 -0
forge_doctor_api/analyzers/iac/parser.py +216 -0
forge_doctor_api/analyzers/openapi/__init__.py +76 -0
forge_doctor_api/analyzers/openapi/detection.py +63 -0
forge_doctor_api/analyzers/openapi/graph.py +171 -0
forge_doctor_api/analyzers/openapi/identity.py +44 -0
forge_doctor_api/analyzers/openapi/knowledge.py +59 -0
forge_doctor_api/analyzers/openapi/loader.py +290 -0
forge_doctor_api/analyzers/openapi/model.py +355 -0
forge_doctor_api/analyzers/openapi/parser.py +952 -0
forge_doctor_api/analyzers/openapi/refs.py +151 -0
forge_doctor_api/analyzers/openapi/shape.py +81 -0
forge_doctor_api/analyzers/routes/__init__.py +33 -0
forge_doctor_api/analyzers/routes/adapter.py +291 -0
forge_doctor_api/analyzers/routes/fastapi.py +971 -0
forge_doctor_api/analyzers/routes/graph.py +101 -0
forge_doctor_api/analyzers/routes/javascript.py +977 -0
forge_doctor_api/analyzers/routes/model.py +122 -0
forge_doctor_api/analyzers/routes/spring.py +541 -0
forge_doctor_api/analyzers/routes/textscan.py +102 -0
forge_doctor_api/analyzers/runtime/__init__.py +53 -0
forge_doctor_api/analyzers/runtime/accesslog.py +68 -0
forge_doctor_api/analyzers/runtime/adapter.py +32 -0
forge_doctor_api/analyzers/runtime/aggregate.py +224 -0
forge_doctor_api/analyzers/runtime/execution.py +408 -0
forge_doctor_api/analyzers/runtime/graph.py +93 -0
forge_doctor_api/analyzers/runtime/history.py +103 -0
forge_doctor_api/analyzers/runtime/loader.py +283 -0
forge_doctor_api/analyzers/runtime/model.py +100 -0
forge_doctor_api/analyzers/runtime/otlp.py +211 -0
forge_doctor_api/analyzers/runtime/stream.py +301 -0
forge_doctor_api/analyzers/version/__init__.py +19 -0
forge_doctor_api/analyzers/version/detect.py +242 -0
forge_doctor_api/analyzers/version/model.py +71 -0
forge_doctor_api/change/__init__.py +41 -0
forge_doctor_api/change/baseline.py +51 -0
forge_doctor_api/change/blast.py +178 -0
forge_doctor_api/change/events.py +372 -0
forge_doctor_api/change/model.py +125 -0
forge_doctor_api/change/pr.py +56 -0
forge_doctor_api/checks/__init__.py +1 -0
forge_doctor_api/checks/apisec/__init__.py +5 -0
forge_doctor_api/checks/apisec/catalog.py +172 -0
forge_doctor_api/checks/apisec/engine.py +549 -0
forge_doctor_api/checks/asyncapi/__init__.py +14 -0
forge_doctor_api/checks/asyncapi/catalog.py +87 -0
forge_doctor_api/checks/asyncapi/engine.py +374 -0
forge_doctor_api/checks/client/__init__.py +16 -0
forge_doctor_api/checks/client/catalog.py +41 -0
forge_doctor_api/checks/client/engine.py +215 -0
forge_doctor_api/checks/compat/__init__.py +27 -0
forge_doctor_api/checks/compat/catalog.py +125 -0
forge_doctor_api/checks/compat/engine.py +982 -0
forge_doctor_api/checks/compat/fingerprint.py +116 -0
forge_doctor_api/checks/drift/__init__.py +38 -0
forge_doctor_api/checks/drift/catalog.py +150 -0
forge_doctor_api/checks/drift/engine.py +608 -0
forge_doctor_api/checks/drift/error_contract.py +127 -0
forge_doctor_api/checks/graphql/__init__.py +15 -0
forge_doctor_api/checks/graphql/catalog.py +150 -0
forge_doctor_api/checks/graphql/engine.py +300 -0
forge_doctor_api/checks/grpc/__init__.py +15 -0
forge_doctor_api/checks/grpc/catalog.py +115 -0
forge_doctor_api/checks/grpc/engine.py +217 -0
forge_doctor_api/checks/oas/__init__.py +6 -0
forge_doctor_api/checks/oas/catalog.py +271 -0
forge_doctor_api/checks/oas/engine.py +766 -0
forge_doctor_api/checks/observability/__init__.py +6 -0
forge_doctor_api/checks/observability/catalog.py +75 -0
forge_doctor_api/checks/observability/engine.py +159 -0
forge_doctor_api/checks/perf/__init__.py +5 -0
forge_doctor_api/checks/perf/catalog.py +104 -0
forge_doctor_api/checks/perf/engine.py +299 -0
forge_doctor_api/checks/relapi/__init__.py +5 -0
forge_doctor_api/checks/relapi/catalog.py +124 -0
forge_doctor_api/checks/relapi/engine.py +418 -0
forge_doctor_api/cli/__init__.py +1596 -0
forge_doctor_api/cli/catalog.py +131 -0
forge_doctor_api/contracts/__init__.py +90 -0
forge_doctor_api/contracts/adapters.py +336 -0
forge_doctor_api/contracts/models.py +658 -0
forge_doctor_api/contracts/schemas.py +244 -0
forge_doctor_api/contracts/validate.py +114 -0
forge_doctor_api/contracts/version.py +73 -0
forge_doctor_api/core/__init__.py +1 -0
forge_doctor_api/core/cache.py +115 -0
forge_doctor_api/core/context.py +105 -0
forge_doctor_api/core/discovery.py +317 -0
forge_doctor_api/core/evidence_store.py +138 -0
forge_doctor_api/core/export.py +53 -0
forge_doctor_api/core/gate.py +101 -0
forge_doctor_api/core/graph.py +387 -0
forge_doctor_api/core/models.py +682 -0
forge_doctor_api/core/plan.py +186 -0
forge_doctor_api/core/redaction.py +106 -0
forge_doctor_api/core/report.py +26 -0
forge_doctor_api/core/stats.py +94 -0
forge_doctor_api/diagnose/__init__.py +23 -0
forge_doctor_api/diagnose/engine.py +328 -0
forge_doctor_api/diagnose/model.py +87 -0
forge_doctor_api/fleet/__init__.py +32 -0
forge_doctor_api/fleet/collect.py +156 -0
forge_doctor_api/fleet/model.py +130 -0
forge_doctor_api/fleet/report.py +503 -0
forge_doctor_api/graphview.py +84 -0
forge_doctor_api/handoff/__init__.py +31 -0
forge_doctor_api/handoff/boundary.py +215 -0
forge_doctor_api/handoff/bundle.py +202 -0
forge_doctor_api/handoff/context.py +281 -0
forge_doctor_api/handoff/decision.py +72 -0
forge_doctor_api/handoff/delta.py +197 -0
forge_doctor_api/handoff/mcp.py +259 -0
forge_doctor_api/handoff/mcp_server.py +274 -0
forge_doctor_api/handoff/model.py +217 -0
forge_doctor_api/handoff/protocol.py +336 -0
forge_doctor_api/handoff/routing.py +84 -0
forge_doctor_api/integrations/__init__.py +0 -0
forge_doctor_api/knowledge/__init__.py +77 -0
forge_doctor_api/knowledge/asyncapi/__init__.py +1 -0
forge_doctor_api/knowledge/asyncapi/versions.yaml +38 -0
forge_doctor_api/knowledge/capability.py +314 -0
forge_doctor_api/knowledge/frameworks/__init__.py +1 -0
forge_doctor_api/knowledge/frameworks/express.yaml +17 -0
forge_doctor_api/knowledge/frameworks/fastapi.yaml +17 -0
forge_doctor_api/knowledge/frameworks/spring.yaml +17 -0
forge_doctor_api/knowledge/gateways/__init__.py +1 -0
forge_doctor_api/knowledge/gateways/aws-api-gateway.yaml +16 -0
forge_doctor_api/knowledge/gateways/capability-map.yaml +41 -0
forge_doctor_api/knowledge/gateways/envoy.yaml +17 -0
forge_doctor_api/knowledge/gateways/kong.yaml +15 -0
forge_doctor_api/knowledge/gateways/nginx.yaml +15 -0
forge_doctor_api/knowledge/graphql/__init__.py +1 -0
forge_doctor_api/knowledge/graphql/spec.yaml +30 -0
forge_doctor_api/knowledge/grpc/__init__.py +1 -0
forge_doctor_api/knowledge/grpc/behaviors.yaml +69 -0
forge_doctor_api/knowledge/http/__init__.py +1 -0
forge_doctor_api/knowledge/http/semantics.yaml +27 -0
forge_doctor_api/knowledge/jsonschema/__init__.py +1 -0
forge_doctor_api/knowledge/jsonschema/dialects.yaml +30 -0
forge_doctor_api/knowledge/loader.py +131 -0
forge_doctor_api/knowledge/manifest.py +229 -0
forge_doctor_api/knowledge/model.py +122 -0
forge_doctor_api/knowledge/openapi/__init__.py +1 -0
forge_doctor_api/knowledge/openapi/versions.yaml +54 -0
forge_doctor_api/knowledge/security/__init__.py +0 -0
forge_doctor_api/knowledge/security/owasp_api_top10.yaml +98 -0
forge_doctor_api/lab/__init__.py +42 -0
forge_doctor_api/lab/capabilities.py +81 -0
forge_doctor_api/lab/loader.py +114 -0
forge_doctor_api/lab/model.py +246 -0
forge_doctor_api/lab/report.py +283 -0
forge_doctor_api/lab/runner.py +299 -0
forge_doctor_api/migrate/__init__.py +41 -0
forge_doctor_api/migrate/engine.py +885 -0
forge_doctor_api/migrate/graph.py +263 -0
forge_doctor_api/migrate/model.py +124 -0
forge_doctor_api/output/__init__.py +17 -0
forge_doctor_api/output/writers.py +140 -0
forge_doctor_api/perf/__init__.py +100 -0
forge_doctor_api/perf/baseline.py +186 -0
forge_doctor_api/perf/budget.py +100 -0
forge_doctor_api/perf/capacity.py +244 -0
forge_doctor_api/perf/correlation.py +91 -0
forge_doctor_api/perf/criticalpath.py +140 -0
forge_doctor_api/perf/experiments.py +215 -0
forge_doctor_api/perf/fanout.py +144 -0
forge_doctor_api/perf/payload.py +72 -0
forge_doctor_api/perf/signals.py +152 -0
forge_doctor_api/perf/stats.py +70 -0
forge_doctor_api/plugins/__init__.py +51 -0
forge_doctor_api/plugins/conformance.py +221 -0
forge_doctor_api/plugins/manifest.py +181 -0
forge_doctor_api/plugins/registry.py +129 -0
forge_doctor_api/plugins/sdk.py +96 -0
forge_doctor_api/plugins/trust.py +92 -0
forge_doctor_api/plugins/validation.py +197 -0
forge_doctor_api/policy/__init__.py +37 -0
forge_doctor_api/policy/engine.py +112 -0
forge_doctor_api/policy/loader.py +208 -0
forge_doctor_api/policy/model.py +116 -0
forge_doctor_api/policy/ownership.py +140 -0
forge_doctor_api/policy/rules.py +255 -0
forge_doctor_api/py.typed +1 -0
forge_doctor_api/reliability/__init__.py +50 -0
forge_doctor_api/reliability/config.py +661 -0
forge_doctor_api/reliability/idempotency.py +46 -0
forge_doctor_api/reliability/model.py +180 -0
forge_doctor_api/reliability/retry.py +93 -0
forge_doctor_api/reliability/slo.py +94 -0
forge_doctor_api/reliability/timeout.py +84 -0
forge_doctor_api/report.py +83 -0
forge_doctor_api/safefix/__init__.py +27 -0
forge_doctor_api/safefix/classify.py +52 -0
forge_doctor_api/safefix/model.py +74 -0
forge_doctor_api/safefix/rules.py +123 -0
forge_doctor_api/scan.py +854 -0
forge_doctor_api/sdk.py +205 -0
forge_doctor_api/security/__init__.py +43 -0
forge_doctor_api/security/knowledge.py +29 -0
forge_doctor_api/security/model.py +257 -0
forge_doctor_api/security/scan.py +1012 -0
forge_doctor_api/service_graph.py +48 -0
forge_doctor_api/temporal.py +247 -0
forge_doctor_api/twin/__init__.py +25 -0
forge_doctor_api/twin/assemble.py +266 -0
forge_doctor_api/twin/drift.py +364 -0
forge_doctor_api/twin/model.py +117 -0
forge_doctor_api/ui/__init__.py +28 -0
forge_doctor_api/ui/app.py +529 -0
forge_doctor_api/ui/home.py +175 -0
forge_doctor_api/ui/i18n.py +143 -0
forge_doctor_api/ui/kit.py +689 -0
forge_doctor_api/ui/screen.py +648 -0
forge_doctor_api/ui/tui.py +124 -0
forge_doctor_api/ui/wizard.py +309 -0
forge_doctor_api/workspace/__init__.py +36 -0
forge_doctor_api/workspace/impact.py +134 -0
forge_doctor_api/workspace/links.py +319 -0
forge_doctor_api/workspace/loader.py +123 -0
forge_doctor_api/workspace/model.py +105 -0
forge_doctor_api-0.2.0.dist-info/METADATA +209 -0
forge_doctor_api-0.2.0.dist-info/RECORD +268 -0
forge_doctor_api-0.2.0.dist-info/WHEEL +4 -0
forge_doctor_api-0.2.0.dist-info/entry_points.txt +3 -0
forge_doctor_api-0.2.0.dist-info/licenses/LICENSE +21 -0

forge_doctor_api/__init__.py ADDED Viewed

@@ -0,0 +1,69 @@
+"""Forge Doctor API: deterministic API architecture intelligence.
+Public surface (stable): `Doctor` facade, `DoctorReport`, core models
+and the handoff bundle. Everything else is internal and may move —
+import from here, not from deep module paths.
+"""
+from forge_doctor_api.core.context import ProjectContext
+from forge_doctor_api.core.discovery import ArtifactInventory
+from forge_doctor_api.core.models import (
+    Confidence,
+    Evidence,
+    EvidenceKind,
+    Finding,
+    Model,
+    Severity,
+    SourceLocation,
+    UnknownFact,
+)
+from forge_doctor_api.core.plan import AnalysisPlan
+from forge_doctor_api.core.report import DomainSummary
+from forge_doctor_api.handoff.bundle import assemble_bundle
+from forge_doctor_api.handoff.model import ApiHandoffBundle
+from forge_doctor_api.handoff.protocol import (
+    ForgeHandoff,
+    ForgeReceipt,
+    ForgeRef,
+    ForgeRequest,
+    ForgeResult,
+)
+from forge_doctor_api.report import DoctorReport
+from forge_doctor_api.sdk import (
+    SDK_VERSION,
+    Doctor,
+    DoctorError,
+    FindingNotFoundError,
+    ProjectUnreadableError,
+)
+__version__ = "0.2.0"
+__all__ = [
+    "SDK_VERSION",
+    "AnalysisPlan",
+    "ApiHandoffBundle",
+    "ArtifactInventory",
+    "Confidence",
+    "Doctor",
+    "DoctorError",
+    "DoctorReport",
+    "DomainSummary",
+    "Evidence",
+    "EvidenceKind",
+    "Finding",
+    "FindingNotFoundError",
+    "ForgeHandoff",
+    "ForgeReceipt",
+    "ForgeRef",
+    "ForgeRequest",
+    "ForgeResult",
+    "Model",
+    "ProjectContext",
+    "ProjectUnreadableError",
+    "Severity",
+    "SourceLocation",
+    "UnknownFact",
+    "__version__",
+    "assemble_bundle",
+]

forge_doctor_api/__main__.py ADDED Viewed

@@ -0,0 +1,3 @@
+from forge_doctor_api.cli import main
+main()

forge_doctor_api/_graphstudio.py ADDED Viewed

@@ -0,0 +1,376 @@
+"""Forge Graph Studio — local-first, read-only graph explorer.
+A zero-dependency stdlib server (``http.server`` on 127.0.0.1) plus a
+single-file HTML/canvas frontend embedded below. No Node, no CDN, no
+build step — the whole app ships as Python package source.
+GET-only by design: exploring a graph can never modify the project
+(§4.4). ``serve()`` never opens a browser unless asked; ``--no-browser``
+prints the URL for SSH port-forwarding.
+"""
+from __future__ import annotations
+import json
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+STUDIO_HTML = r"""<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Forge Graph Studio</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+:root{--bg:#0d1117;--panel:#161b22;--fg:#e6edf3;--dim:#8b949e;--line:#30363d;--acc:#58a6ff}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--fg);
+font:13px/1.4 ui-monospace,Consolas,monospace;display:grid;
+grid-template-columns:220px 1fr 280px;grid-template-rows:44px 1fr 26px;height:100vh}
+header{grid-column:1/4;display:flex;gap:12px;align-items:center;padding:0 12px;
+background:var(--panel);border-bottom:1px solid var(--line)}
+header b{color:var(--acc)}select,input{background:var(--bg);color:var(--fg);
+border:1px solid var(--line);border-radius:4px;padding:4px 6px}
+#side,#insp{background:var(--panel);padding:10px;overflow:auto}
+#side{border-right:1px solid var(--line)}#insp{border-left:1px solid var(--line)}
+#wrap{position:relative;overflow:hidden}canvas{display:block;width:100%;height:100%;cursor:grab}
+footer{grid-column:1/4;background:var(--panel);border-top:1px solid var(--line);
+display:flex;gap:16px;padding:4px 12px;color:var(--dim)}
+.k{word-break:break-all}.dim{color:var(--dim)}h4{margin:10px 0 4px;color:var(--dim);
+text-transform:uppercase;font-size:11px;letter-spacing:.05em}
+label.f{display:block;margin:2px 0;cursor:pointer}
+#insp .pill{display:inline-block;border:1px solid var(--line);border-radius:10px;
+padding:0 8px;margin:1px 2px;font-size:11px}
+.ev{color:var(--acc);font-size:11px;word-break:break-all}
+</style></head>
+<body>
+<header><b>FORGE GRAPH STUDIO</b>
+<select id="gsel"></select>
+<input id="q" placeholder="search…" size="20">
+<span id="meta" class="dim"></span></header>
+<div id="side"><h4>Layers</h4><div id="layers"></div>
+<h4>Edge kinds</h4><div id="ekinds"></div>
+<h4>Legend</h4><div id="legend" class="dim"></div></div>
+<div id="wrap"><canvas id="cv"></canvas></div>
+<div id="insp"><h4>Inspector</h4><div id="ibody" class="dim">select a node or edge</div></div>
+<footer><span id="stats"></span><span id="prov"></span>
+<span class="dim">scroll=zoom · drag=pan · click=inspect · n=neighbors ·
+e=export · d=diff · s=snapshot · esc=reset</span></footer>
+<script>
+let G={nodes:[],edges:[]},L={},view={x:0,y:0,s:1},sel=null,hover=null,
+kindsOn={},ekindsOn={},PAL={},running=true;
+const cv=document.getElementById('cv'),cx=cv.getContext('2d');
+const KCOLORS=['#58a6ff','#f78166','#7ee787','#ffa657','#d2a8ff','#76e3ea','#ff9bce','#e3b341'];
+const ESTYLE={observed:[],declared:[6,3],inferred:[3,4],planned:[2,4],desired:[8,3],unknown:[1,5]};
+function pal(k){if(!(k in PAL))PAL[k]=KCOLORS[Object.keys(PAL).length%KCOLORS.length];return PAL[k]}
+async function loadGraphs(){const r=await fetch('/api/graphs');const d=await r.json();
+const s=document.getElementById('gsel');s.innerHTML='';
+d.graphs.forEach(g=>{const o=document.createElement('option');o.value=g.graph_id;
+o.textContent=`${g.provider_id} · ${g.graph_id}`+
+` (${g.node_count}/${g.edge_count})`;s.appendChild(o)});
+if(d.graphs.length)loadGraph(d.graphs[0].graph_id);
+s.onchange=e=>loadGraph(e.target.value)}
+async function loadGraph(id){const r=await fetch('/api/graph/'+encodeURIComponent(id));
+const d=await r.json();sel=null;L={};
+G.nodes=(d.nodes||[]).map(n=>({...n,x:Math.random()*600-300,y:Math.random()*600-300,vx:0,vy:0,deg:0}));
+G.edges=(d.edges||[]);
+const byId={};G.nodes.forEach(n=>{byId[n.id]=n});
+G.edges.forEach(e=>{if(byId[e.source])byId[e.source].deg++;if(byId[e.target])byId[e.target].deg++});
+G.edges=G.edges.filter(e=>byId[e.source]&&byId[e.target]);
+kindsOn={};G.nodes.forEach(n=>kindsOn[n.kind]=true);
+ekindsOn={};G.edges.forEach(e=>ekindsOn[e.kind]=true);
+sidePanel();document.getElementById('meta').textContent=
+`${d.descriptor.provider_id} · ${d.descriptor.domain} · ${d.descriptor.generated_at||''}`;
+document.getElementById('prov').textContent=
+(d.descriptor.limitations||[]).join(' | ').slice(0,120);
+running=true;tick()}
+function sidePanel(){const L=document.getElementById('layers'),E=document.getElementById('ekinds');
+L.innerHTML='';E.innerHTML='';
+Object.keys(kindsOn).sort().forEach(k=>{L.innerHTML+=
+`<label class="f"><input type="checkbox" checked data-k="${k}">`+
+` <span style="color:${pal(k)}">●</span> ${k}</label>`});
+Object.keys(ekindsOn).sort().forEach(k=>{E.innerHTML+=
+`<label class="f"><input type="checkbox" checked data-ek="${k}"> ${k}</label>`});
+L.querySelectorAll('input').forEach(i=>i.onchange=e=>{kindsOn[e.target.dataset.k]=e.target.checked});
+E.querySelectorAll('input').forEach(i=>i.onchange=e=>{ekindsOn[e.target.dataset.ek]=e.target.checked});
+document.getElementById('legend').innerHTML=
+Object.keys(ESTYLE).map(s=>`<div>─ ${s}</div>`).join('')}
+function tick(){let n=0;const byId={};G.nodes.forEach(x=>byId[x.id]=x);
+for(let i=0;i<G.nodes.length;i++)for(let j=i+1;j<G.nodes.length;j++){
+const a=G.nodes[i],b=G.nodes[j];let dx=a.x-b.x,dy=a.y-b.y,d=dx*dx+dy*dy+40;
+const f=Math.min(2000/d,40);a.vx+=dx/d*f;a.vy+=dy/d*f;b.vx-=dx/d*f;b.vy-=dy/d*f}
+G.edges.forEach(e=>{const a=byId[e.source],b=byId[e.target];
+const dx=b.x-a.x,dy=b.y-a.y,d=Math.hypot(dx,dy)||1,f=(d-120)*0.02;
+a.vx+=dx/d*f*d/120;a.vy+=dy/d*f*d/120;b.vx-=dx/d*f*d/120;b.vy-=dy/d*f*d/120});
+G.nodes.forEach(a=>{a.vx-=a.x*0.001;a.vy-=a.y*0.001;a.vx*=0.85;a.vy*=0.85;
+a.x+=a.vx;a.y+=a.vy;if(Math.abs(a.vx)+Math.abs(a.vy)>0.1)n++});
+draw();if(n>0&&running)requestAnimationFrame(tick)}
+function toS(x,y){const r=cv.getBoundingClientRect();
+return[(x*view.s)+r.width/2+view.x,(y*view.s)+r.height/2+view.y]}
+function draw(){const r=cv.getBoundingClientRect();
+if(cv.width!==r.width*devicePixelRatio){cv.width=r.width*devicePixelRatio;
+cv.height=r.height*devicePixelRatio}
+cx.setTransform(devicePixelRatio,0,0,devicePixelRatio,0,0);
+cx.clearRect(0,0,r.width,r.height);
+const q=(document.getElementById('q').value||'').toLowerCase();
+const vis={};let vc=0,ec=0;
+G.nodes.forEach(n=>{const s=(n.label||'')+' '+n.id;
+vis[n.id]=kindsOn[n.kind]&&(!q||s.toLowerCase().includes(q))&&
+(!focusSet||focusSet.has(n.id));
+if(vis[n.id])vc++});
+G.edges.forEach(e=>{if(!vis[e.source]||!vis[e.target]||!ekindsOn[e.kind])return;ec++;
+const a=G.nodes.find(n=>n.id===e.source),b=G.nodes.find(n=>n.id===e.target);
+const[x1,y1]=toS(a.x,a.y),[x2,y2]=toS(b.x,b.y);
+cx.strokeStyle=e===sel?'#f0f6fc':'#444c56';cx.lineWidth=e===sel?2:1;
+cx.setLineDash(ESTYLE[e.epistemic_state]||ESTYLE.unknown);
+cx.beginPath();cx.moveTo(x1,y1);cx.lineTo(x2,y2);cx.stroke();
+// arrowhead
+const an=Math.atan2(y2-y1,x2-x1);cx.setLineDash([]);cx.beginPath();
+cx.moveTo(x2,y2);cx.lineTo(x2-8*Math.cos(an-0.5),y2-8*Math.sin(an-0.5));
+cx.lineTo(x2-8*Math.cos(an+0.5),y2-8*Math.sin(an+0.5));cx.fillStyle=cx.strokeStyle;cx.fill()});
+cx.setLineDash([]);
+G.nodes.forEach(n=>{if(!vis[n.id])return;const[x,y]=toS(n.x,n.y);
+const rad=4+Math.min(n.deg,12);
+cx.beginPath();cx.arc(x,y,rad,0,7);
+const dcol=drawDiffColors&&DC[drawDiffColors[n.id]];
+cx.fillStyle=n===sel?'#f0f6fc':(n===hover?'#fff':(dcol||pal(n.kind)));cx.fill();
+if(n===sel){cx.strokeStyle='#58a6ff';cx.lineWidth=2;cx.stroke()}
+if(view.s>0.5||n.deg>4){cx.fillStyle='#8b949e';cx.font='10px monospace';
+cx.fillText((n.label||n.id).slice(0,24),x+rad+2,y+3)}});
+document.getElementById('stats').textContent=`${vc} nodes · ${ec} edges visible`}
+cv.onwheel=e=>{e.preventDefault();const r=cv.getBoundingClientRect();
+const mx=e.clientX-r.left-r.width/2,my=e.clientY-r.top-r.height/2;
+const f=e.deltaY<0?1.15:0.87;view.x=(view.x-mx)*f+mx;view.y=(view.y-my)*f+my;
+view.s*=f;draw()};
+let drag=null;cv.onmousedown=e=>{const p=pick(e);drag={e,node:p.node,mx:view.x,my:view.y}};
+cv.onmousemove=e=>{if(drag){const r=cv.getBoundingClientRect();
+if(drag.node){drag.node.x=(e.clientX-r.left-r.width/2-view.x)/view.s;
+drag.node.y=(e.clientY-r.top-r.height/2-view.y)/view.s}else{
+view.x=drag.mx+e.clientX-drag.e.clientX;view.y=drag.my+e.clientY-drag.e.clientY}
+draw()}else{const p=pick(e);hover=p.node;draw()}};
+cv.onmouseup=e=>{const p=pick(e);
+if(!drag||(Math.abs(e.clientX-drag.e.clientX)<4&&Math.abs(e.clientY-drag.e.clientY)<4)){
+sel=p.node||p.edge||null;inspect()}
+drag=null;draw()};
+function pick(e){const r=cv.getBoundingClientRect();
+const wx=(e.clientX-r.left-r.width/2-view.x)/view.s,
+wy=(e.clientY-r.top-r.height/2-view.y)/view.s;
+for(const n of G.nodes)if(Math.hypot(n.x-wx,n.y-wy)<12/view.s+4)return{node:n};
+for(const ed of G.edges){const a=G.nodes.find(n=>n.id===ed.source),
+b=G.nodes.find(n=>n.id===ed.target);if(!a||!b)continue;
+const L2=(b.x-a.x)**2+(b.y-a.y)**2||1;
+const t=Math.max(0,Math.min(1,((wx-a.x)*(b.x-a.x)+(wy-a.y)*(b.y-a.y))/L2));
+if(Math.hypot(wx-(a.x+t*(b.x-a.x)),wy-(a.y+t*(b.y-a.y)))<6/view.s)return{edge:ed}}
+return{}}
+function inspect(){const b=document.getElementById('ibody');if(!sel){
+b.innerHTML='<span class="dim">select a node or edge</span>';return}
+let h='';
+if(sel.kind&&sel.label!==undefined&&!sel.source){
+h=`<div class="k"><b>${sel.label||sel.id}</b></div>
+<span class="pill">${sel.kind}</span><span class="pill">${sel.epistemic_state}</span>
+<span class="pill">${sel.source_provider||''}</span>
+<h4>Attributes</h4><div class="k">${JSON.stringify(sel.attributes||{},null,1)}</div>
+<h4>Evidence</h4>${(sel.evidence_refs||[]).map(e=>`<div class="ev">${e}</div>`)
+.join('')||'<span class="dim">none</span>'}
+<h4>Edges (${G.edges.filter(e=>e.source===sel.id||e.target===sel.id).length})</h4>`;
+}else{h=`<div class="k"><b>${sel.kind}</b></div>
+<div class="k dim">${sel.source} → ${sel.target}</div>
+<span class="pill">${sel.epistemic_state}</span><span class="pill">${sel.provenance||''}</span>
+${sel.confidence!=null?`<span class="pill">conf ${sel.confidence}</span>`:''}
+<h4>Evidence</h4>${(sel.evidence_refs||[]).map(e=>`<div class="ev">${e}</div>`)
+.join('')||'<span class="dim">none</span>'}
+<h4>Temporal</h4><div class="k">${Object.keys(sel.temporal||{}).length?
+JSON.stringify(sel.temporal):'none'}</div>`}
+b.innerHTML=h}
+document.getElementById('q').oninput=draw;
+// --- premium interactions (Cycle 4): neighbors / export / diff / snapshot ---
+let focusSet=null; // BFS subgraph when 'n' pressed
+function neighbors(seed){const adj={};G.edges.forEach(e=>{
+(adj[e.source]=adj[e.source]||new Set()).add(e.target);
+(adj[e.target]=adj[e.target]||new Set()).add(e.source)});
+const seen=new Set([seed]);let fr=[seed];
+for(let d=0;d<2&&fr.length;d++){const nx=[];fr.forEach(id=>{
+(adj[id]||[]).forEach(m=>{if(!seen.has(m)){seen.add(m);nx.push(m)}})});fr=nx}
+return seen}
+async function exportVisible(){const q=(document.getElementById('q').value||'').toLowerCase();
+const vis={};G.nodes.forEach(n=>{const s=(n.label||'')+' '+n.id;
+vis[n.id]=kindsOn[n.kind]&&(!q||s.toLowerCase().includes(q))&&(!focusSet||focusSet.has(n.id))});
+const doc={exported_at:new Date().toISOString(),
+nodes:G.nodes.filter(n=>vis[n.id]).map(n=>({id:n.id,kind:n.kind,label:n.label,
+epistemic_state:n.epistemic_state,attributes:n.attributes,evidence_refs:n.evidence_refs})),
+edges:G.edges.filter(e=>vis[e.source]&&vis[e.target]&&ekindsOn[e.kind])};
+const a=document.createElement('a');a.href=URL.createObjectURL(
+new Blob([JSON.stringify(doc,null,1)],{type:'application/json'}));
+a.download='forge-graph-subgraph.json';a.click()}
+let diffRef=null;
+async function diffMode(){const r=await fetch('/api/graphs');const d=await r.json();
+if(d.graphs.length<2){document.getElementById('prov').textContent=
+'diff needs ≥2 graphs loaded';return}
+const other=d.graphs.map(g=>g.graph_id).find(id=>id!==curId)||d.graphs[0].graph_id;
+const rr=await fetch('/api/graph/'+encodeURIComponent(other));const o=await rr.json();
+const on={};(o.nodes||[]).forEach(n=>on[n.id]=n);
+const oe={};(o.edges||[]).forEach(e=>oe[e.source+'>'+e.target+':'+e.kind]=1);
+const eadded=G.edges.filter(e=>!oe[e.source+'>'+e.target+':'+e.kind]).length;
+let added=0,removed=0,changed=0;const cls={};
+G.nodes.forEach(n=>{if(!on[n.id]){cls[n.id]='added';added++}else if(
+JSON.stringify(on[n.id].attributes)!==JSON.stringify(n.attributes)||
+on[n.id].epistemic_state!==n.epistemic_state){cls[n.id]='changed';changed++}else cls[n.id]='same'});
+removed=(o.nodes||[]).filter(n=>!G.nodes.find(x=>x.id===n.id)).length;
+diffRef={other,cls};
+drawDiffColors=cls;
+document.getElementById('prov').textContent=
+`diff vs ${other}: +${added} ~${changed} −${removed} nodes · +${eadded} edges (esc clears)`;
+draw()}
+let drawDiffColors=null;
+const DC={added:'#7ee787',removed:'#f78166',changed:'#ffa657',same:null};
+let curId=null;
+const _loadGraph=loadGraph;
+loadGraph=async function(id){curId=id;diffRef=null;drawDiffColors=null;
+await _loadGraph(id)}
+function snapshotSave(){try{localStorage.setItem('forge-graph-snap',
+JSON.stringify({graph:curId,view,q:document.getElementById('q').value,
+kinds:kindsOn,ekinds:ekindsOn,when:Date.now()}));
+document.getElementById('prov').textContent='snapshot saved (s restores)'}catch(e){}}
+function snapshotLoad(){try{const s=JSON.parse(localStorage.getItem('forge-graph-snap')||'null');
+if(!s)return;view=s.view;document.getElementById('q').value=s.q||'';
+Object.assign(kindsOn,s.kinds||{});Object.assign(ekindsOn,s.ekinds||{});draw()}catch(e){}}
+document.onkeydown=e=>{
+if(e.key==='Escape'){view={x:0,y:0,s:1};sel=null;focusSet=null;diffRef=null;
+drawDiffColors=null;inspect();draw()}
+else if(e.key==='n'&&sel&&sel.id!==undefined){focusSet=focusSet?null:neighbors(sel.id);draw()}
+else if(e.key==='e')exportVisible()
+else if(e.key==='d')diffMode()
+else if(e.key==='s'){localStorage.getItem('forge-graph-snap')?snapshotLoad():snapshotSave()}};
+loadGraphs();
+</script></body></html>
+"""
+def _handler(views: dict[str, dict[str, Any]]) -> type[BaseHTTPRequestHandler]:
+    class StudioHandler(BaseHTTPRequestHandler):
+        def log_message(self, fmt: str, *args: object) -> None:  # quiet
+            pass
+        def _send(self, code: int, body: bytes, ctype: str) -> None:
+            self.send_response(code)
+            self.send_header("Content-Type", ctype)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+        def _json(self, code: int, doc: object) -> None:
+            self._send(code, json.dumps(doc, default=str).encode(), "application/json")
+        def do_GET(self) -> None:  # noqa: N802 - stdlib naming
+            path = self.path.split("?")[0].rstrip("/") or "/"
+            if path == "/":
+                self._send(200, STUDIO_HTML.encode(), "text/html; charset=utf-8")
+                return
+            if path == "/api/health":
+                self._json(200, {"status": "ok", "graphs": len(views)})
+                return
+            if path == "/api/graphs":
+                self._json(200, {"graphs": [v["descriptor"] for v in views.values()]})
+                return
+            if path.startswith("/api/graph/"):
+                gid = path[len("/api/graph/"):]
+                view = views.get(gid)
+                if view is None:
+                    self._json(404, {"error": f"unknown graph {gid!r}"})
+                    return
+                self._json(200, view)
+                return
+            self._json(404, {"error": "not found"})
+        def do_POST(self) -> None:  # read-only by design (§4.4)
+            self._json(405, {"error": "Graph Studio is read-only"})
+        do_PUT = do_DELETE = do_PATCH = do_POST
+    return StudioHandler
+def serve(
+    views: list[dict[str, Any]],
+    *,
+    host: str = "127.0.0.1",
+    port: int = 0,
+    open_browser: bool = True,
+    out: Any = None,
+) -> int:
+    """Serve the studio until Ctrl+C. ``views`` are ForgeGraphView dicts.
+    Binds loopback only — never exposes graphs on the network. With
+    ``open_browser=False`` (``--no-browser``, remote/SSH) the URL is
+    printed for port-forwarding instead.
+    """
+    out = out or __import__("sys").stdout
+    by_id = {v["descriptor"]["graph_id"]: v for v in views}
+    httpd = ThreadingHTTPServer((host, port), _handler(by_id))
+    bound = httpd.server_address[1]
+    url = f"http://{host}:{bound}/"
+    if open_browser:
+        threading.Timer(0.3, lambda: webbrowser.open(url)).start()
+        print(f"Graph Studio → {url}  (Ctrl+C to stop)", file=out)
+    else:
+        print(f"Graph Studio listening on {url}", file=out)
+        print(f"  remote? forward with: ssh -L {bound}:127.0.0.1:{bound} <host>", file=out)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.server_close()
+    return 0
+def graph_studio_enabled(
+    root: Path | str | None = None,
+    *,
+    state_rel: str = ".forge/install",
+    user_state_rel: str = "~/.forge/install",
+) -> bool:
+    """Was Graph Studio declined at install time?
+    ``components.json`` under the forge's state dir records the optional-
+    component selection (``graph_studio: false``). Absence means the
+    default — enabled — so checkouts and pre-component installs keep
+    working.
+    """
+    import json
+    candidates: list[Path] = []
+    if root:
+        candidates.append(Path(root) / state_rel / "components.json")
+    candidates.append(Path(user_state_rel).expanduser() / "components.json")
+    for p in candidates:
+        if not p.is_file():
+            continue
+        try:
+            doc = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if "graph_studio" in doc:
+            return bool(doc["graph_studio"])
+    return True
+def open_studio(
+    views: list[Any],
+    *,
+    open_browser: bool = True,
+    port: int = 0,
+    out: Any = None,
+) -> int:
+    """Entry for ``graph ui``: accept views or view objects, then serve."""
+    docs = [v.to_dict() if hasattr(v, "to_dict") else v for v in views]
+    if not docs:
+        print(
+            "no graphs available — produce one first (see `graph build`/`graph` docs)",
+            file=out,
+        )
+        return 2
+    return serve(docs, open_browser=open_browser, port=port, out=out)

forge_doctor_api/_graphview.py ADDED Viewed

@@ -0,0 +1,181 @@
+"""ForgeGraphView/v1 — the visualization contract for Graph Studio.
+A read-only, rendering-ready projection of a forge's real graph. The
+graph engines stay authoritative; this contract only *carries* their
+data to a viewer without losing provenance, epistemic state or evidence
+references. Layout coordinates are deliberately absent — they belong to
+the visualization layer, not the model.
+"""
+from __future__ import annotations
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from typing import Any
+GRAPHVIEW_SCHEMA = "forge/ForgeGraphView/v1"
+GRAPH_DESCRIPTOR_SCHEMA = "forge/GraphDescriptor/v1"
+# Epistemic states a view may carry. Engines map their own vocabulary
+# onto these explicitly; unmapped states stay "unknown", never upgraded.
+EPISTEMIC_STATES = (
+    "observed",
+    "declared",
+    "planned",
+    "desired",
+    "inferred",
+    "unknown",
+)
+# Capabilities an adapter may declare — only real ones.
+GRAPH_CAPABILITIES = (
+    "snapshots",
+    "node_inspect",
+    "edge_inspect",
+    "neighbors",
+    "paths",
+    "dependency_traversal",
+    "impact_analysis",
+    "snapshot_diff",
+    "temporal",
+    "search",
+    "filter",
+    "export",
+)
+# Engine vocabulary → view vocabulary (explicit, reversible): a state an
+# engine uses that has a view equivalent is translated; anything else
+# stays "unknown" — never silently upgraded to observed/declared.
+EPISTEMIC_TRANSLATION = {
+    "explicit": "declared",
+    "asserted": "declared",
+    "actual": "observed",
+}
+def _check(state: str) -> str:
+    if state in EPISTEMIC_STATES:
+        return state
+    return EPISTEMIC_TRANSLATION.get(state, "unknown")
+@dataclass(frozen=True, kw_only=True)
+class GraphDescriptor:
+    """Summary of one graph a provider can expose (§1.2)."""
+    graph_id: str
+    provider_id: str
+    domain: str
+    graph_schema: str = GRAPH_DESCRIPTOR_SCHEMA
+    snapshot_id: str = ""
+    generated_at: str = ""
+    node_count: int = 0
+    edge_count: int = 0
+    available_layers: tuple[str, ...] = ()
+    available_queries: tuple[str, ...] = ()
+    capabilities: tuple[str, ...] = ()
+    limitations: tuple[str, ...] = ()
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+@dataclass(frozen=True, kw_only=True)
+class GraphNodeView:
+    """One node, with engine provenance preserved (§1.3)."""
+    id: str
+    kind: str
+    label: str
+    domain: str = ""
+    source_provider: str = ""
+    attributes: dict[str, Any] = field(default_factory=dict)
+    epistemic_state: str = "unknown"
+    evidence_refs: tuple[str, ...] = ()
+    snapshot_ref: str = ""
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "epistemic_state", _check(self.epistemic_state))
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+@dataclass(frozen=True, kw_only=True)
+class GraphEdgeView:
+    """One directed edge; direction and semantics preserved (§1.4)."""
+    id: str
+    source: str
+    target: str
+    kind: str
+    direction: str = "directed"
+    provenance: str = "unknown"
+    epistemic_state: str = "unknown"
+    evidence_refs: tuple[str, ...] = ()
+    confidence: float | None = None
+    temporal: dict[str, Any] = field(default_factory=dict)
+    attributes: dict[str, Any] = field(default_factory=dict)
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "epistemic_state", _check(self.epistemic_state))
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        if self.confidence is None:
+            d.pop("confidence")
+        return d
+@dataclass(frozen=True, kw_only=True)
+class ForgeGraphView:
+    """A complete view document: descriptor + nodes + edges."""
+    descriptor: GraphDescriptor
+    nodes: tuple[GraphNodeView, ...] = ()
+    edges: tuple[GraphEdgeView, ...] = ()
+    schema: str = GRAPHVIEW_SCHEMA
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema": self.schema,
+            "descriptor": self.descriptor.to_dict(),
+            "nodes": [n.to_dict() for n in self.nodes],
+            "edges": [e.to_dict() for e in self.edges],
+        }
+    @staticmethod
+    def from_dict(doc: dict[str, Any]) -> ForgeGraphView:
+        d = doc["descriptor"]
+        descriptor = GraphDescriptor(
+            **{k: tuple(v) if isinstance(v, list) else v for k, v in d.items()}
+        )
+        nodes = tuple(
+            GraphNodeView(
+                **{k: tuple(v) if isinstance(v, list) else v for k, v in n.items()}
+            )
+            for n in doc.get("nodes", [])
+        )
+        edges = tuple(
+            GraphEdgeView(
+                **{k: tuple(v) if isinstance(v, list) else v for k, v in e.items()}
+            )
+            for e in doc.get("edges", [])
+        )
+        return ForgeGraphView(descriptor=descriptor, nodes=nodes, edges=edges)
+def new_descriptor(*, provider_id: str, domain: str, graph_id: str | None = None,
+                   capabilities: tuple[str, ...] = (),
+                   limitations: tuple[str, ...] = ()) -> GraphDescriptor:
+    """A descriptor with real provenance stamps."""
+    return GraphDescriptor(
+        graph_id=graph_id or f"graph-{uuid.uuid4().hex[:8]}",
+        provider_id=provider_id,
+        domain=domain,
+        generated_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        capabilities=tuple(c for c in capabilities if c in GRAPH_CAPABILITIES),
+        limitations=limitations,
+    )

forge_doctor_api/analyzers/__init__.py ADDED Viewed

File without changes

forge_doctor_api/analyzers/asyncapi/__init__.py ADDED Viewed

@@ -0,0 +1,39 @@
+"""AsyncAPI semantic model (§20)."""
+from forge_doctor_api.analyzers.asyncapi.compat import diff_asyncapi_models
+from forge_doctor_api.analyzers.asyncapi.graph import async_graph
+from forge_doctor_api.analyzers.asyncapi.model import (
+    ASYNCAPI_MODEL_SCHEMA_VERSION,
+    AsyncAction,
+    AsyncApiChannel,
+    AsyncApiDocument,
+    AsyncApiIssue,
+    AsyncApiMessage,
+    AsyncApiOperation,
+    AsyncApiProjectModel,
+    AsyncApiSchema,
+    AsyncApiSecurityRequirement,
+    AsyncApiServer,
+    AsyncDocumentStatus,
+    AsyncIssueCode,
+)
+from forge_doctor_api.analyzers.asyncapi.parser import load_asyncapi_project
+__all__ = [
+    "ASYNCAPI_MODEL_SCHEMA_VERSION",
+    "AsyncAction",
+    "AsyncApiChannel",
+    "AsyncApiDocument",
+    "AsyncApiIssue",
+    "AsyncApiMessage",
+    "AsyncApiOperation",
+    "AsyncApiProjectModel",
+    "AsyncApiSchema",
+    "AsyncApiSecurityRequirement",
+    "AsyncApiServer",
+    "AsyncDocumentStatus",
+    "AsyncIssueCode",
+    "async_graph",
+    "diff_asyncapi_models",
+    "load_asyncapi_project",
+]