progmune-runtime 2.1.6 → 3.2.0

package/dist/knowledge-api.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Knowledge API — Protocol Knowledge Base as a Service
+ *
+ * REST endpoints for querying the Protocol Knowledge Base.
+ * External tools and customers can consume protocol knowledge
+ * without installing Progmune.
+ *
+ * Usage:
+ *   npx ts-node src/knowledge-api.ts
+ *   PROGMUNE_KB_PORT=3400 npx ts-node src/knowledge-api.ts
+ *
+ * Endpoints:
+ *   GET /knowledge/assets              — all assets
+ *   GET /knowledge/assets/:id          — single asset
+ *   GET /knowledge/assets/:id/versions — version history
+ *   GET /knowledge/assets/:id/evidence — evidence per repo
+ *   GET /knowledge/summary             — aggregate stats
+ *   GET /health                        — service health
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const protocol_knowledge_1 = require("./protocol-knowledge");
+const evidence_repository_1 = require("./evidence-repository");
+const knowledge_graph_1 = require("./knowledge-graph");
+const PORT = parseInt(process.env.PROGMUNE_KB_PORT || "3400", 10);
+function json(res, data, status = 200) {
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    });
+    res.end(JSON.stringify(data, null, 2));
+}
+function html(res, body, status = 200) {
+    res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(body);
+}
+const server = http.createServer((req, res) => {
+    const url = req.url || "/";
+    const method = req.method || "GET";
+    if (method === "OPTIONS") {
+        res.writeHead(204, { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, OPTIONS", "Access-Control-Allow-Headers": "Content-Type" });
+        res.end();
+        return;
+    }
+    // Health
+    if (url === "/health") {
+        json(res, { status: "ok", service: "Progmune Knowledge API", version: "1.0.0" });
+        return;
+    }
+    // Home
+    if (url === "/" || url === "") {
+        html(res, renderHome());
+        return;
+    }
+    const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+    // GET /knowledge/summary
+    if (url === "/knowledge/summary") {
+        json(res, {
+            ...kb.summary,
+            stableAssets: kb.units.filter(a => a.maturity === "stable").map(a => a.name),
+            validatedAssets: kb.units.filter(a => a.maturity === "validated").map(a => a.name),
+            generated: kb.generated,
+        });
+        return;
+    }
+    // GET /knowledge/assets
+    if (url === "/knowledge/assets") {
+        const summary = kb.units.map(a => ({
+            id: a.id, name: a.name, category: a.category,
+            version: a.currentVersion, maturity: a.maturity,
+            confidence: a.confidence, validatedRepos: a.validatedRepos,
+            validatedSequences: a.validatedSequences,
+        }));
+        json(res, { total: summary.length, assets: summary });
+        return;
+    }
+    // GET /knowledge/assets/:id/versions
+    if (url.startsWith("/knowledge/assets/") && url.endsWith("/versions")) {
+        const id = url.split("/knowledge/assets/")[1]?.replace("/versions", "");
+        const asset = kb.units.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: "Asset not found" }, 404);
+            return;
+        }
+        json(res, { id: asset.id, name: asset.name, currentVersion: asset.currentVersion, history: asset.versionHistory });
+        return;
+    }
+    // GET /knowledge/assets/:id/evidence
+    if (url.startsWith("/knowledge/assets/") && url.endsWith("/evidence")) {
+        const id = url.split("/knowledge/assets/")[1]?.replace("/evidence", "");
+        const asset = kb.units.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: "Asset not found" }, 404);
+            return;
+        }
+        json(res, { id: asset.id, name: asset.name, evidence: asset.evidence || [] });
+        return;
+    }
+    // GET /knowledge/assets/:id
+    if (url.startsWith("/knowledge/assets/")) {
+        const id = url.split("/knowledge/assets/")[1];
+        const asset = kb.units.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: "Asset not found" }, 404);
+            return;
+        }
+        json(res, asset);
+        return;
+    }
+    // GET /knowledge/evidence
+    if (url === "/knowledge/evidence") {
+        const er = (0, evidence_repository_1.buildEvidenceRepository)();
+        json(res, er);
+        return;
+    }
+    // GET /knowledge/evidence/:repo
+    if (url.startsWith("/knowledge/evidence/")) {
+        const repo = url.split("/knowledge/evidence/")[1];
+        const er = (0, evidence_repository_1.buildEvidenceRepository)();
+        const record = er.repos.find(r => r.repo === repo);
+        if (!record) {
+            json(res, { error: "Repo not found" }, 404);
+            return;
+        }
+        json(res, record);
+        return;
+    }
+    // GET /knowledge/network
+    if (url === "/knowledge/network") {
+        const g = (0, knowledge_graph_1.buildKnowledgeGraph)();
+        json(res, { nodes: g.nodes.length, edges: g.edges.length, adjacency: g.adjacency, topNodes: g.nodes.map(n => ({ id: n.id, name: n.name, domain: n.domain, maturity: n.maturity, inDegree: g.inDegree[n.id] || 0, outDegree: g.outDegree[n.id] || 0 })).sort((a, b) => (b.inDegree + b.outDegree) - (a.inDegree + a.outDegree)) });
+        return;
+    }
+    // GET /knowledge/network/:nodeId
+    if (url.startsWith("/knowledge/network/")) {
+        const nodeId = url.split("/knowledge/network/")[1];
+        const g = (0, knowledge_graph_1.buildKnowledgeGraph)();
+        const node = g.nodes.find(n => n.id === nodeId);
+        if (!node) {
+            json(res, { error: "Node not found" }, 404);
+            return;
+        }
+        const { getDependencies, getDependents } = require("./knowledge-graph");
+        json(res, {
+            node,
+            dependsOn: getDependencies(g, nodeId).map((n) => ({ id: n.id, name: n.name })),
+            dependedBy: getDependents(g, nodeId).map((n) => ({ id: n.id, name: n.name })),
+            edges: g.edges.filter(e => e.from === nodeId || e.to === nodeId),
+        });
+        return;
+    }
+    // GET /knowledge/packages
+    if (url === "/knowledge/packages") {
+        const fs = require("fs");
+        const pkgs = [];
+        if (fs.existsSync("benchmarks")) {
+            for (const f of fs.readdirSync("benchmarks")) {
+                if (f.startsWith("kb-package-") && f.endsWith(".json")) {
+                    try {
+                        pkgs.push(JSON.parse(fs.readFileSync(`benchmarks/${f}`, "utf-8")));
+                    }
+                    catch { }
+                }
+            }
+        }
+        json(res, {
+            registry: "Progmune Knowledge Package Registry",
+            version: "1.0.0",
+            total: pkgs.length,
+            packages: pkgs.map(p => ({
+                name: p.domain,
+                version: p.version,
+                units: p.summary?.totalUnits,
+                stable: p.summary?.stableUnits,
+                concepts: p.summary?.totalConcepts,
+                repos: p.summary?.validatedRepos,
+                rfcs: p.summary?.rfcReferences,
+                download: `/knowledge/packages/${p.domain.toLowerCase()}`,
+            })),
+        });
+        return;
+    }
+    // GET /knowledge/packages/:domain — download package
+    if (url.startsWith("/knowledge/packages/")) {
+        const domain = url.split("/knowledge/packages/")[1];
+        const pkgFile = `benchmarks/kb-package-${domain.toLowerCase()}.json`;
+        const fs = require("fs");
+        if (!fs.existsSync(pkgFile)) {
+            json(res, { error: "Package not found" }, 404);
+            return;
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Content-Disposition": `attachment; filename="kb-package-${domain.toLowerCase()}.json"`,
+            "X-Package-Version": pkg.version,
+            "X-Package-Domain": pkg.domain,
+            "X-Package-Units": String(pkg.summary?.totalUnits || 0),
+            "Access-Control-Allow-Origin": "*",
+        });
+        res.end(JSON.stringify(pkg, null, 2));
+        return;
+    }
+    // GET /knowledge/compatibility
+    if (url === "/knowledge/compatibility") {
+        const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+        json(res, {
+            knowledgeVersion: kb.version,
+            runtimeVersion: "1.0.0",
+            packages: kb.units.map(u => u.domain).filter((v, i, a) => a.indexOf(v) === i).map(d => ({
+                domain: d,
+                packageVersion: "1.0.0",
+                knowledgeVersion: kb.version,
+                compatible: true,
+                units: kb.units.filter(u => u.domain === d).length,
+                stableUnits: kb.units.filter(u => u.domain === d && u.maturity === "stable").length,
+            })),
+        });
+        return;
+    }
+    // 404
+    json(res, { error: "Not found" }, 404);
+});
+function renderHome() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Progmune Knowledge API</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;background:#0a0a0a;color:#d4d4d4;max-width:800px;margin:40px auto;padding:20px}
+h1{color:#fff;font-size:22px;margin-bottom:8px}
+.sub{color:#666;font-size:13px;margin-bottom:32px}
+.endpoint{background:#111;border:1px solid #222;border-radius:8px;padding:14px 18px;margin-bottom:10px}
+.endpoint .method{display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:700;margin-right:10px;background:#052e16;color:#22c55e}
+.endpoint .path{font-family:'SF Mono',Menlo,Consolas,monospace;font-size:14px;color:#fff}
+.endpoint .desc{font-size:12px;color:#888;margin-top:4px}
+pre{background:#111;border-radius:8px;padding:16px;font-size:12px;color:#a5d6ff;margin-top:16px;overflow-x:auto}
+.footer{margin-top:40px;padding-top:16px;border-top:1px solid #222;font-size:11px;color:#444;text-align:center}
+a{color:#60a5fa}
+</style>
+</head>
+<body>
+<h1>Progmune Knowledge API</h1>
+<div class="sub">Protocol Knowledge Base as a Service — query protocol assets, evidence, and version history</div>
+
+<div class="endpoint"><span class="method">GET</span><span class="path">/knowledge/assets</span><div class="desc">List all protocol assets (id, name, maturity, confidence, repos)</div></div>
+<div class="endpoint"><span class="method">GET</span><span class="path">/knowledge/assets/:id</span><div class="desc">Full asset metadata (steps, examples, anti-patterns, state machine, evidence)</div></div>
+<div class="endpoint"><span class="method">GET</span><span class="path">/knowledge/assets/:id/versions</span><div class="desc">Version history with changelog</div></div>
+<div class="endpoint"><span class="method">GET</span><span class="path">/knowledge/assets/:id/evidence</span><div class="desc">Evidence per repository</div></div>
+<div class="endpoint"><span class="method">GET</span><span class="path">/knowledge/summary</span><div class="desc">Aggregate stats (maturity distribution, confidence, repos, sequences)</div></div>
+
+<h3 style="margin-top:24px;color:#fff">Example</h3>
+<pre>curl http://localhost:${PORT}/knowledge/assets/PROTO-TLS
+
+{
+  "id": "PROTO-TLS",
+  "name": "TLS Handshake",
+  "maturity": "stable",
+  "currentVersion": "1.0.0",
+  "confidence": 85,
+  "validatedRepos": ["curl", "nginx"],
+  "evidence": [...],
+  "versionHistory": [...]
+}</pre>
+
+<div class="footer">Progmune Runtime · <a href="https://github.com/shenlian19831109/progmune-runtime">GitHub</a></div>
+</body>
+</html>`;
+}
+server.listen(PORT, () => {
+    console.error(`\n  Knowledge API: http://localhost:${PORT}`);
+    console.error(`  Assets:        http://localhost:${PORT}/knowledge/assets`);
+    console.error(`  Summary:       http://localhost:${PORT}/knowledge/summary\n`);
+});