@a5c-ai/agent-catalog 5.0.1-staging.c9bb2c61

package/dist/evidence-projection.d.ts

@@ -0,0 +1,4 @@
+import type { GraphNode, GraphRelationship } from "./models";
+export declare function buildClaimsByEvidence(claimNodes: Iterable<GraphNode>, evidenceNodes: Iterable<GraphNode>, relationships: Iterable<Pick<GraphRelationship, "from" | "to" | "relation">>): Map<string, GraphNode[]>;
+export declare function getEvidenceClaimStatement(evidenceId: string, claimsByEvidence: ReadonlyMap<string, GraphNode[]>): string;
+//# sourceMappingURL=evidence-projection.d.ts.map

package/dist/evidence-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-projection.d.ts","sourceRoot":"","sources":["../src/evidence-projection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM7D,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC/B,aAAa,EAAE,QAAQ,CAAC,SAAS,CAAC,EAClC,aAAa,EAAE,QAAQ,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC,CAAC,GAC3E,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CA0B1B;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,GACjD,MAAM,CAER"}

package/dist/evidence-projection.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClaimsByEvidence = buildClaimsByEvidence;
+exports.getEvidenceClaimStatement = getEvidenceClaimStatement;
+function valueAsString(value) {
+    return typeof value === "string" ? value : "";
+}
+function buildClaimsByEvidence(claimNodes, evidenceNodes, relationships) {
+    const claimsByGraphId = new Map(Array.from(claimNodes, (node) => [valueAsString(node.id), node]));
+    const evidenceByGraphId = new Map(Array.from(evidenceNodes, (node) => [valueAsString(node.id), node]));
+    const claimsByEvidence = new Map();
+    for (const relationship of relationships) {
+        if (relationship.relation !== "sourced_from") {
+            continue;
+        }
+        const claimNode = claimsByGraphId.get(relationship.from);
+        const evidenceNode = evidenceByGraphId.get(relationship.to);
+        if (!claimNode || !evidenceNode) {
+            continue;
+        }
+        const evidenceId = valueAsString(evidenceNode.evidenceId);
+        const evidenceClaims = claimsByEvidence.get(evidenceId);
+        if (evidenceClaims) {
+            evidenceClaims.push(claimNode);
+        }
+        else {
+            claimsByEvidence.set(evidenceId, [claimNode]);
+        }
+    }
+    return claimsByEvidence;
+}
+function getEvidenceClaimStatement(evidenceId, claimsByEvidence) {
+    return valueAsString(claimsByEvidence.get(evidenceId)?.[0]?.statement);
+}

package/dist/evidence.d.ts

@@ -0,0 +1,13 @@
+import type { ClaimRecord, EvidenceRecord, OntologyEvidenceExport, OntologyEvidenceManifest, OntologyEvidenceSearchResult, SubjectProvenance } from "./models";
+export declare function getOntologyEvidenceManifest(): OntologyEvidenceManifest;
+export declare function getOntologyEvidenceSnapshot(): OntologyEvidenceExport;
+export declare function listOntologyEvidenceSources(): EvidenceRecord[];
+export declare function getOntologyEvidenceSource(evidenceId: string): EvidenceRecord | undefined;
+export declare function listOntologyClaims(): ClaimRecord[];
+export declare function getOntologyClaim(claimId: string): ClaimRecord | undefined;
+export declare function listClaimsForSubject(subjectId: string): ClaimRecord[];
+export declare function listClaimsForEvidence(evidenceId: string): ClaimRecord[];
+export declare function listEvidenceForSubject(subjectId: string): EvidenceRecord[];
+export declare function getSubjectProvenance(subjectId: string): SubjectProvenance;
+export declare function searchOntologyEvidence(query: string): OntologyEvidenceSearchResult;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAIV,WAAW,EACX,cAAc,EAEd,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAG5B,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAiLlB,wBAAgB,2BAA2B,IAAI,wBAAwB,CAEtE;AAED,wBAAgB,2BAA2B,IAAI,sBAAsB,CAQpE;AAED,wBAAgB,2BAA2B,IAAI,cAAc,EAAE,CAE9D;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAGxF;AAED,wBAAgB,kBAAkB,IAAI,WAAW,EAAE,CAElD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAGzE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAErE;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE,CAEvE;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE,CAK1E;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAMzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAoBlF"}

package/dist/evidence.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOntologyEvidenceManifest = getOntologyEvidenceManifest;
+exports.getOntologyEvidenceSnapshot = getOntologyEvidenceSnapshot;
+exports.listOntologyEvidenceSources = listOntologyEvidenceSources;
+exports.getOntologyEvidenceSource = getOntologyEvidenceSource;
+exports.listOntologyClaims = listOntologyClaims;
+exports.getOntologyClaim = getOntologyClaim;
+exports.listClaimsForSubject = listClaimsForSubject;
+exports.listClaimsForEvidence = listClaimsForEvidence;
+exports.listEvidenceForSubject = listEvidenceForSubject;
+exports.getSubjectProvenance = getSubjectProvenance;
+exports.searchOntologyEvidence = searchOntologyEvidence;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const assets_1 = require("./assets");
+const evidence_projection_1 = require("./evidence-projection");
+const graph_1 = require("./graph");
+const transport_mux_cutover_1 = require("./transport-mux-cutover");
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function evidenceRoot() {
+    return node_path_1.default.dirname((0, assets_1.resolveCatalogEvidenceAssetPath)("ontology-evidence", "manifest.json"));
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read JSON asset ${filePath}: ${reason}`);
+    }
+}
+function manifestPath() {
+    return node_path_1.default.join(evidenceRoot(), "manifest.json");
+}
+function valueAsString(value) {
+    return typeof value === "string" ? value : "";
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function claimConfidence(value) {
+    const normalized = valueAsString(value);
+    return normalized === "high" || normalized === "medium" ? normalized : "low";
+}
+function claimProvenanceKind(value) {
+    const normalized = valueAsString(value);
+    if (normalized === "repo-observation" || normalized === "vendor-documentation") {
+        return normalized;
+    }
+    return "vendor-inference";
+}
+function claimEvidenceStrength(value) {
+    const normalized = valueAsString(value);
+    if (normalized === "corroborated" || normalized === "partial") {
+        return normalized;
+    }
+    return "inferred";
+}
+function loadManifest() {
+    return readJson(manifestPath());
+}
+function loadShard(descriptor) {
+    return readJson(node_path_1.default.join(evidenceRoot(), descriptor.relativePath));
+}
+function loadEvidenceNodes(manifest) {
+    return manifest.shards
+        .filter((descriptor) => descriptor.entryKind === "evidence-sources")
+        .flatMap((descriptor) => loadShard(descriptor).entries);
+}
+function loadClaimNodes(manifest) {
+    return manifest.shards
+        .filter((descriptor) => descriptor.entryKind === "claims")
+        .flatMap((descriptor) => loadShard(descriptor).entries);
+}
+let cachedEvidenceState;
+function buildEvidenceState() {
+    try {
+        const manifest = loadManifest();
+        const evidenceSourceNodes = loadEvidenceNodes(manifest);
+        const claimNodes = loadClaimNodes(manifest);
+        const graph = (0, graph_1.getCatalogGraph)();
+        const claimsById = new Map(claimNodes.map((node) => [valueAsString(node.claimId), node]));
+        const evidenceById = new Map(evidenceSourceNodes.map((node) => [valueAsString(node.evidenceId), node]));
+        const claimNodeByGraphId = new Map(claimNodes.map((node) => [valueAsString(node.id), node]));
+        const claimsBySubject = new Map();
+        const claimsByEvidence = (0, evidence_projection_1.buildClaimsByEvidence)(claimNodes, evidenceSourceNodes, graph.edges);
+        for (const edge of graph.edges) {
+            if (edge.relation !== "supported_by_claim") {
+                continue;
+            }
+            const claimNode = claimNodeByGraphId.get(edge.to);
+            if (!claimNode) {
+                continue;
+            }
+            const subjectBucket = claimsBySubject.get(edge.from);
+            if (subjectBucket) {
+                subjectBucket.push(claimNode);
+            }
+            else {
+                claimsBySubject.set(edge.from, [claimNode]);
+            }
+        }
+        return {
+            manifest,
+            evidenceSourceNodes,
+            claimNodes,
+            claimsById,
+            evidenceById,
+            claimsBySubject,
+            claimsByEvidence,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load ontology evidence assets for @a5c-ai/agent-catalog. Ensure evidence/ontology-evidence/manifest.json and referenced shards are packaged and valid JSON. Cause: ${reason}`);
+    }
+}
+function getEvidenceState() {
+    if (!cachedEvidenceState) {
+        cachedEvidenceState = buildEvidenceState();
+    }
+    return cachedEvidenceState;
+}
+function toClaimRecord(node) {
+    const evidenceIds = stringArray(node.evidenceIds);
+    return {
+        claimId: valueAsString(node.claimId),
+        statement: valueAsString(node.statement),
+        subjectKind: valueAsString(node.subjectKind),
+        subjectId: valueAsString(node.subjectId),
+        confidence: claimConfidence(node.confidence),
+        status: (0, transport_mux_cutover_1.effectiveTransportMuxClaimStatus)(valueAsString(node.status), evidenceIds),
+        provenanceKind: claimProvenanceKind(node.provenanceKind),
+        evidenceStrength: claimEvidenceStrength(node.evidenceStrength),
+        evidenceIds,
+        unresolvedGaps: (0, transport_mux_cutover_1.effectiveTransportMuxUnresolvedGaps)(stringArray(node.unresolvedGaps), evidenceIds),
+    };
+}
+function toEvidenceRecord(node) {
+    const evidenceState = getEvidenceState();
+    const evidenceId = valueAsString(node.evidenceId);
+    const freshnessWindowDays = typeof node.freshnessWindowDays === "number" && Number.isFinite(node.freshnessWindowDays)
+        ? node.freshnessWindowDays
+        : undefined;
+    return {
+        evidenceId,
+        kind: valueAsString(node.kindLabel) === "web" ? "web" : "repo",
+        sourcePathOrUrl: valueAsString(node.sourcePathOrUrl),
+        excerptLocator: valueAsString(node.locator),
+        claim: (0, evidence_projection_1.getEvidenceClaimStatement)(evidenceId, evidenceState.claimsByEvidence),
+        capturedAt: valueAsString(node.capturedAt),
+        trustLevel: valueAsString(node.trustLevel),
+        reviewOwner: valueAsString(node.reviewOwner),
+        reviewedAt: valueAsString(node.reviewedAt),
+        freshnessWindowDays,
+    };
+}
+function searchTextMatches(node, normalizedQuery, fields) {
+    return fields.some((field) => valueAsString(node[field]).toLowerCase().includes(normalizedQuery));
+}
+function getOntologyEvidenceManifest() {
+    return clone(getEvidenceState().manifest);
+}
+function getOntologyEvidenceSnapshot() {
+    const evidenceState = getEvidenceState();
+    return {
+        generatedAt: evidenceState.manifest.generatedAt,
+        manifest: clone(evidenceState.manifest),
+        evidenceSources: clone(evidenceState.evidenceSourceNodes),
+        claims: clone(evidenceState.claimNodes),
+    };
+}
+function listOntologyEvidenceSources() {
+    return getEvidenceState().evidenceSourceNodes.map(toEvidenceRecord).map(clone);
+}
+function getOntologyEvidenceSource(evidenceId) {
+    const node = getEvidenceState().evidenceById.get(evidenceId);
+    return node ? clone(toEvidenceRecord(node)) : undefined;
+}
+function listOntologyClaims() {
+    return getEvidenceState().claimNodes.map(toClaimRecord).map(clone);
+}
+function getOntologyClaim(claimId) {
+    const node = getEvidenceState().claimsById.get(claimId);
+    return node ? clone(toClaimRecord(node)) : undefined;
+}
+function listClaimsForSubject(subjectId) {
+    return (getEvidenceState().claimsBySubject.get(subjectId) ?? []).map(toClaimRecord).map(clone);
+}
+function listClaimsForEvidence(evidenceId) {
+    return (getEvidenceState().claimsByEvidence.get(evidenceId) ?? []).map(toClaimRecord).map(clone);
+}
+function listEvidenceForSubject(subjectId) {
+    const evidenceIds = new Set(listClaimsForSubject(subjectId).flatMap((claim) => claim.evidenceIds));
+    return [...evidenceIds]
+        .map((evidenceId) => getOntologyEvidenceSource(evidenceId))
+        .filter((record) => Boolean(record));
+}
+function getSubjectProvenance(subjectId) {
+    return {
+        subjectId,
+        claims: listClaimsForSubject(subjectId),
+        evidence: listEvidenceForSubject(subjectId),
+    };
+}
+function searchOntologyEvidence(query) {
+    const evidenceState = getEvidenceState();
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return { query, evidence: [], claims: [] };
+    }
+    return {
+        query,
+        evidence: evidenceState.evidenceSourceNodes.filter((node) => searchTextMatches(node, normalizedQuery, ["evidenceId", "sourcePathOrUrl", "locator", "kindLabel"]))
+            .map(toEvidenceRecord)
+            .map(clone),
+        claims: evidenceState.claimNodes.filter((node) => searchTextMatches(node, normalizedQuery, ["claimId", "statement", "subjectId", "subjectKind", "confidence", "status"]))
+            .map(toClaimRecord)
+            .map(clone),
+    };
+}

package/dist/graph.d.ts

@@ -0,0 +1,20 @@
+import type { CatalogGraph, GraphDocument, GraphEdge, GraphNode, GraphRelationship, OntologySchema } from "./models";
+export declare function getCatalogGraph(): CatalogGraph;
+export declare function getGraphDocument(): GraphDocument;
+export declare function getOntologySchema(): OntologySchema;
+export declare function listGraphNodes(): GraphNode[];
+export declare function listNodesByKind(kind: GraphNode["kind"]): GraphNode[];
+export declare function getNodeById<TNode extends GraphNode = GraphNode>(nodeId: string): TNode | undefined;
+export declare function listGraphEdges(): GraphRelationship[];
+export declare function listRelationshipsForNode(nodeId: string): GraphRelationship[];
+export declare function listRelationshipsByRelation(relation: string): GraphRelationship[];
+export declare function listOutgoingTargets(nodeId: string, relation: string): GraphNode[];
+export declare function listIncomingSources(nodeId: string, relation: string): GraphNode[];
+export declare function listEdgesForNode(catalog: {
+    graph: GraphEdge[];
+}, nodeId: string): GraphEdge[];
+export declare function listEdgesByRelation(catalog: {
+    graph: GraphEdge[];
+}, relation: string): GraphEdge[];
+export declare function assertGraphFileCoverage(): void;
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,cAAc,EACf,MAAM,UAAU,CAAC;AAuJlB,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED,wBAAgB,cAAc,IAAI,SAAS,EAAE,CAE5C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,EAAE,CAEpE;AAED,wBAAgB,WAAW,CAAC,KAAK,SAAS,SAAS,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAElG;AAED,wBAAgB,cAAc,IAAI,iBAAiB,EAAE,CAEpD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAE5E;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAEjF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAIjF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAIjF;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAE7F;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAElG;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAY9C"}

package/dist/graph.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogGraph = getCatalogGraph;
+exports.getGraphDocument = getGraphDocument;
+exports.getOntologySchema = getOntologySchema;
+exports.listGraphNodes = listGraphNodes;
+exports.listNodesByKind = listNodesByKind;
+exports.getNodeById = getNodeById;
+exports.listGraphEdges = listGraphEdges;
+exports.listRelationshipsForNode = listRelationshipsForNode;
+exports.listRelationshipsByRelation = listRelationshipsByRelation;
+exports.listOutgoingTargets = listOutgoingTargets;
+exports.listIncomingSources = listIncomingSources;
+exports.listEdgesForNode = listEdgesForNode;
+exports.listEdgesByRelation = listEdgesByRelation;
+exports.assertGraphFileCoverage = assertGraphFileCoverage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
+const assets_1 = require("./assets");
+function listYamlFilesRecursively(targetPath) {
+    const stat = node_fs_1.default.statSync(targetPath);
+    if (stat.isFile()) {
+        return targetPath.endsWith(".yaml") ? [targetPath] : [];
+    }
+    return node_fs_1.default
+        .readdirSync(targetPath, { withFileTypes: true })
+        .flatMap((entry) => listYamlFilesRecursively(node_path_1.default.join(targetPath, entry.name)))
+        .sort((left, right) => left.localeCompare(right));
+}
+let cachedGraph;
+function graphRoot() {
+    return node_path_1.default.dirname((0, assets_1.resolveCatalogGraphAssetPath)("agent-catalog.graph.yaml"));
+}
+function readYamlFile(filePath) {
+    try {
+        return (0, yaml_1.parse)(node_fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read YAML asset ${filePath}: ${reason}`);
+    }
+}
+function ensureArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected ${label} to be an array.`);
+    }
+    return value;
+}
+function ensureString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Expected ${label} to be a non-empty string.`);
+    }
+    return value;
+}
+function validateRequiredAttributes(subject, required, label) {
+    for (const attribute of required) {
+        if (!(attribute in subject)) {
+            throw new Error(`Missing required ${label} attribute "${attribute}".`);
+        }
+    }
+}
+function loadCatalogGraph() {
+    if (cachedGraph) {
+        return cachedGraph;
+    }
+    try {
+        const rootDir = graphRoot();
+        const document = readYamlFile(node_path_1.default.join(rootDir, "agent-catalog.graph.yaml"));
+        const schema = readYamlFile(node_path_1.default.join(rootDir, document.schemaPath));
+        validateRequiredAttributes(document, schema.nodeKinds.GraphDocument.requiredAttributes, "GraphDocument");
+        validateRequiredAttributes(schema, schema.nodeKinds.OntologySchema.requiredAttributes, "OntologySchema");
+        const nodes = [];
+        const edges = [];
+        for (const importPath of document.imports) {
+            for (const resolvedPath of listYamlFilesRecursively(node_path_1.default.join(rootDir, importPath))) {
+                const parsed = readYamlFile(resolvedPath);
+                if (parsed.kind === "NodeDocument") {
+                    nodes.push(...parsed.nodes);
+                    continue;
+                }
+                if (parsed.kind === "EdgeDocument") {
+                    edges.push(...parsed.edges);
+                    continue;
+                }
+                throw new Error(`Unsupported graph document kind in ${resolvedPath}.`);
+            }
+        }
+        const nodeIds = new Set([document.id, schema.id]);
+        const nodeKinds = new Map([
+            [document.id, "GraphDocument"],
+            [schema.id, "OntologySchema"],
+        ]);
+        for (const node of nodes) {
+            ensureString(node.id, "node.id");
+            ensureString(node.kind, `node.kind for ${node.id}`);
+            const definition = schema.nodeKinds[node.kind];
+            if (!definition) {
+                throw new Error(`Unknown node kind "${node.kind}" for ${node.id}.`);
+            }
+            validateRequiredAttributes(node, definition.requiredAttributes, `node ${node.id}`);
+            nodeIds.add(node.id);
+            nodeKinds.set(node.id, node.kind);
+        }
+        for (const edge of edges) {
+            ensureString(edge.id, "edge.id");
+            ensureString(edge.relation, `edge.relation for ${edge.id}`);
+            ensureString(edge.from, `edge.from for ${edge.id}`);
+            ensureString(edge.to, `edge.to for ${edge.id}`);
+            const definition = schema.edgeKinds[edge.relation];
+            if (!definition) {
+                throw new Error(`Unknown edge relation "${edge.relation}" for ${edge.id}.`);
+            }
+            validateRequiredAttributes(edge, definition.requiredAttributes, `edge ${edge.id}`);
+            if (!nodeIds.has(edge.from)) {
+                throw new Error(`Edge ${edge.id} references unknown source node ${edge.from}.`);
+            }
+            if (!nodeIds.has(edge.to)) {
+                throw new Error(`Edge ${edge.id} references unknown target node ${edge.to}.`);
+            }
+            if (definition.from && !definition.from.includes(nodeKinds.get(edge.from) ?? "")) {
+                throw new Error(`Edge ${edge.id} has invalid source kind ${nodeKinds.get(edge.from)} for relation ${edge.relation}.`);
+            }
+            if (definition.to && !definition.to.includes(nodeKinds.get(edge.to) ?? "")) {
+                throw new Error(`Edge ${edge.id} has invalid target kind ${nodeKinds.get(edge.to)} for relation ${edge.relation}.`);
+            }
+        }
+        cachedGraph = { document, schema, nodes, edges };
+        return cachedGraph;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load graph assets for @a5c-ai/agent-catalog. Ensure graph/agent-catalog.graph.yaml and imported YAML files are packaged and valid YAML. Cause: ${reason}`);
+    }
+}
+function getCatalogGraph() {
+    return loadCatalogGraph();
+}
+function getGraphDocument() {
+    return loadCatalogGraph().document;
+}
+function getOntologySchema() {
+    return loadCatalogGraph().schema;
+}
+function listGraphNodes() {
+    return [...loadCatalogGraph().nodes];
+}
+function listNodesByKind(kind) {
+    return loadCatalogGraph().nodes.filter((node) => node.kind === kind);
+}
+function getNodeById(nodeId) {
+    return loadCatalogGraph().nodes.find((node) => node.id === nodeId);
+}
+function listGraphEdges() {
+    return [...loadCatalogGraph().edges];
+}
+function listRelationshipsForNode(nodeId) {
+    return loadCatalogGraph().edges.filter((edge) => edge.from === nodeId || edge.to === nodeId);
+}
+function listRelationshipsByRelation(relation) {
+    return loadCatalogGraph().edges.filter((edge) => edge.relation === relation);
+}
+function listOutgoingTargets(nodeId, relation) {
+    const graph = loadCatalogGraph();
+    const targetIds = graph.edges.filter((edge) => edge.from === nodeId && edge.relation === relation).map((edge) => edge.to);
+    return graph.nodes.filter((node) => targetIds.includes(node.id));
+}
+function listIncomingSources(nodeId, relation) {
+    const graph = loadCatalogGraph();
+    const sourceIds = graph.edges.filter((edge) => edge.to === nodeId && edge.relation === relation).map((edge) => edge.from);
+    return graph.nodes.filter((node) => sourceIds.includes(node.id));
+}
+function listEdgesForNode(catalog, nodeId) {
+    return catalog.graph.filter((edge) => edge.from === nodeId || edge.to === nodeId);
+}
+function listEdgesByRelation(catalog, relation) {
+    return catalog.graph.filter((edge) => edge.relation === relation);
+}
+function assertGraphFileCoverage() {
+    const document = getGraphDocument();
+    ensureArray(document.imports, "GraphDocument.imports");
+    for (const importPath of document.imports) {
+        const absolutePath = node_path_1.default.join(graphRoot(), ensureString(importPath, "GraphDocument.imports[]"));
+        if (!node_fs_1.default.existsSync(absolutePath)) {
+            throw new Error(`Graph import is missing: ${importPath}`);
+        }
+        if (listYamlFilesRecursively(absolutePath).length === 0) {
+            throw new Error(`Graph import has no YAML files: ${importPath}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./models";
+export * from "./assets";
+export * from "./data";
+export * from "./evidence";
+export { listOntologyClaims } from "./evidence";
+export * from "./graph";
+export * from "./sdk";
+export * from "./cli";
+export * from "./ui";
+export * from "./discovery";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listOntologyClaims = void 0;
+__exportStar(require("./models"), exports);
+__exportStar(require("./assets"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./evidence"), exports);
+var evidence_1 = require("./evidence");
+Object.defineProperty(exports, "listOntologyClaims", { enumerable: true, get: function () { return evidence_1.listOntologyClaims; } });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./sdk"), exports);
+__exportStar(require("./cli"), exports);
+__exportStar(require("./ui"), exports);
+__exportStar(require("./discovery"), exports);