pi-harness-runtime 0.10.27 → 0.10.43

package/packages/knowledge-graph/src/mcp-client.ts

@@ -5,242 +5,233 @@
  */
 
 import type {
-	KnowledgeNode,
-	KnowledgeEdge,
-	KnowledgeGraph,
-	SearchOptions,
-	SearchResult,
-	TencentDBConfig,
-} from "./types.js";
+  KnowledgeNode,
+  KnowledgeEdge,
+  KnowledgeGraph,
+  SearchOptions,
+  SearchResult,
+  TencentDBConfig,
+} from './types.js';
 
 /**
  * Sync graph to TencentDB Knowledge Service
  */
 export async function syncGraphToKnowledgeService(
-	graph: KnowledgeGraph,
-	config: TencentDBConfig,
+  graph: KnowledgeGraph,
+  config: TencentDBConfig
 ): Promise<{ synced: number; errors: string[] }> {
-	const response = await fetch(
-		`${config.knowledgeUrl}/v3/knowledge/graph/sync`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"x-tdai-user-key": config.userKey,
-				"x-tdai-service-id": config.serviceId,
-			},
-			body: JSON.stringify({
-				nodes: graph.nodes.map((n) => ({
-					id: n.id,
-					type: n.type,
-					...n.data,
-				})),
-				edges: graph.edges.map((e) => ({
-					from: e.from,
-					to: e.to,
-					type: e.type,
-				})),
-			}),
-		},
-	);
-
-	if (!response.ok) {
-		const error = await response.text();
-		return { synced: 0, errors: [error] };
-	}
-
-	return { synced: graph.nodes.length, errors: [] };
+  const response = await fetch(`${config.knowledgeUrl}/v3/knowledge/graph/sync`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-tdai-user-key': config.userKey,
+      'x-tdai-service-id': config.serviceId,
+    },
+    body: JSON.stringify({
+      nodes: graph.nodes.map(n => ({
+        id: n.id,
+        type: n.type,
+        ...n.data,
+      })),
+      edges: graph.edges.map(e => ({
+        from: e.from,
+        to: e.to,
+        type: e.type,
+      })),
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    return { synced: 0, errors: [error] };
+  }
+
+  return { synced: graph.nodes.length, errors: [] };
 }
 
 /**
  * Search knowledge graph
  */
 export async function searchGraph(
-	query: string,
-	config: TencentDBConfig,
-	options: SearchOptions = {},
+  query: string,
+  config: TencentDBConfig,
+  options: SearchOptions = {}
 ): Promise<SearchResult[]> {
-	const limit = options.limit ?? 10;
-
-	const response = await fetch(
-		`${config.knowledgeUrl}/v3/knowledge/graph/search`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"x-tdai-user-key": config.userKey,
-				"x-tdai-service-id": config.serviceId,
-			},
-			body: JSON.stringify({
-				query,
-				limit,
-				type: options.type,
-				tags: options.tags,
-			}),
-		},
-	);
-
-	if (!response.ok) {
-		throw new Error(`Search failed: ${response.statusText}`);
-	}
-
-	const data = (await response.json()) as {
-		results: Array<{
-			id: string;
-			type: string;
-			title: string;
-			description?: string;
-			tags: string[];
-			score: number;
-		}>;
-	};
-
-	return data.results.map((r) => ({
-		node: {
-			id: r.id,
-			type: r.type as KnowledgeNode["type"],
-			data: {
-				title: r.title,
-				description: r.description,
-				tags: r.tags,
-			},
-		},
-		score: r.score,
-	}));
+  const limit = options.limit ?? 10;
+
+  const response = await fetch(`${config.knowledgeUrl}/v3/knowledge/graph/search`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-tdai-user-key': config.userKey,
+      'x-tdai-service-id': config.serviceId,
+    },
+    body: JSON.stringify({
+      query,
+      limit,
+      type: options.type,
+      tags: options.tags,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Search failed: ${response.statusText}`);
+  }
+
+  const data = (await response.json()) as {
+    results: Array<{
+      id: string;
+      type: string;
+      title: string;
+      description?: string;
+      tags: string[];
+      score: number;
+    }>;
+  };
+
+  return data.results.map(r => ({
+    node: {
+      id: r.id,
+      type: r.type as KnowledgeNode['type'],
+      data: {
+        title: r.title,
+        description: r.description,
+        tags: r.tags,
+      },
+    },
+    score: r.score,
+  }));
 }
 
 /**
  * Query graph by relationship type
  */
 export async function queryRelationships(
-	config: TencentDBConfig,
-	options: {
-		type?: KnowledgeEdge["type"];
-		from?: string;
-		to?: string;
-	},
+  config: TencentDBConfig,
+  options: {
+    type?: KnowledgeEdge['type'];
+    from?: string;
+    to?: string;
+  }
 ): Promise<KnowledgeEdge[]> {
-	const response = await fetch(
-		`${config.knowledgeUrl}/v3/knowledge/graph/query`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"x-tdai-user-key": config.userKey,
-				"x-tdai-service-id": config.serviceId,
-			},
-			body: JSON.stringify(options),
-		},
-	);
-
-	if (!response.ok) {
-		throw new Error(`Query failed: ${response.statusText}`);
-	}
-
-	const data = (await response.json()) as {
-		edges: Array<{
-			from: string;
-			to: string;
-			type: string;
-		}>;
-	};
-
-	return data.edges.map((e) => ({
-		from: e.from,
-		to: e.to,
-		type: e.type as KnowledgeEdge["type"],
-	}));
+  const response = await fetch(`${config.knowledgeUrl}/v3/knowledge/graph/query`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-tdai-user-key': config.userKey,
+      'x-tdai-service-id': config.serviceId,
+    },
+    body: JSON.stringify(options),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Query failed: ${response.statusText}`);
+  }
+
+  const data = (await response.json()) as {
+    edges: Array<{
+      from: string;
+      to: string;
+      type: string;
+    }>;
+  };
+
+  return data.edges.map(e => ({
+    from: e.from,
+    to: e.to,
+    type: e.type as KnowledgeEdge['type'],
+  }));
 }
 
 /**
  * Get a specific node by ID
  */
 export async function getNode(
-	nodeId: string,
-	config: TencentDBConfig,
+  nodeId: string,
+  config: TencentDBConfig
 ): Promise<KnowledgeNode | null> {
-	const response = await fetch(
-		`${config.knowledgeUrl}/v3/knowledge/graph/node/${encodeURIComponent(nodeId)}`,
-		{
-			headers: {
-				"x-tdai-user-key": config.userKey,
-				"x-tdai-service-id": config.serviceId,
-			},
-		},
-	);
-
-	if (response.status === 404) {
-		return null;
-	}
-
-	if (!response.ok) {
-		throw new Error(`Get node failed: ${response.statusText}`);
-	}
-
-	const data = (await response.json()) as {
-		id: string;
-		type: string;
-		title: string;
-		description?: string;
-		tags: string[];
-		source?: string;
-	};
-
-	return {
-		id: data.id,
-		type: data.type as KnowledgeNode["type"],
-		data: {
-			title: data.title,
-			description: data.description,
-			tags: data.tags,
-			source: data.source,
-		},
-	};
+  const response = await fetch(
+    `${config.knowledgeUrl}/v3/knowledge/graph/node/${encodeURIComponent(nodeId)}`,
+    {
+      headers: {
+        'x-tdai-user-key': config.userKey,
+        'x-tdai-service-id': config.serviceId,
+      },
+    }
+  );
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  if (!response.ok) {
+    throw new Error(`Get node failed: ${response.statusText}`);
+  }
+
+  const data = (await response.json()) as {
+    id: string;
+    type: string;
+    title: string;
+    description?: string;
+    tags: string[];
+    source?: string;
+  };
+
+  return {
+    id: data.id,
+    type: data.type as KnowledgeNode['type'],
+    data: {
+      title: data.title,
+      description: data.description,
+      tags: data.tags,
+      source: data.source,
+    },
+  };
 }
 
 /**
  * Find skills that implement a specific RFC
  */
 export async function findByRFC(
-	rfcId: string,
-	config: TencentDBConfig,
+  rfcId: string,
+  config: TencentDBConfig
 ): Promise<KnowledgeNode[]> {
-	const edges = await queryRelationships(config, {
-		type: "implements",
-		to: rfcId.startsWith("rfc:") ? rfcId : `rfc:${rfcId}`,
-	});
-
-	const nodes: KnowledgeNode[] = [];
-	for (const edge of edges) {
-		const node = await getNode(edge.from, config);
-		if (node) {
-			nodes.push(node);
-		}
-	}
-
-	return nodes;
+  const edges = await queryRelationships(config, {
+    type: 'implements',
+    to: rfcId.startsWith('rfc:') ? rfcId : `rfc:${rfcId}`,
+  });
+
+  const nodes: KnowledgeNode[] = [];
+  for (const edge of edges) {
+    const node = await getNode(edge.from, config);
+    if (node) {
+      nodes.push(node);
+    }
+  }
+
+  return nodes;
 }
 
 /**
  * Find related skills
  */
 export async function findRelated(
-	skillId: string,
-	config: TencentDBConfig,
-	maxResults = 5,
+  skillId: string,
+  config: TencentDBConfig,
+  maxResults = 5
 ): Promise<KnowledgeNode[]> {
-	const edges = await queryRelationships(config, {
-		type: "related_to",
-		from: skillId.startsWith("skill:") ? skillId : `skill:${skillId}`,
-	});
-
-	const nodes: KnowledgeNode[] = [];
-	for (const edge of edges.slice(0, maxResults)) {
-		const node = await getNode(edge.to, config);
-		if (node) {
-			nodes.push(node);
-		}
-	}
-
-	return nodes;
+  const edges = await queryRelationships(config, {
+    type: 'related_to',
+    from: skillId.startsWith('skill:') ? skillId : `skill:${skillId}`,
+  });
+
+  const nodes: KnowledgeNode[] = [];
+  for (const edge of edges.slice(0, maxResults)) {
+    const node = await getNode(edge.to, config);
+    if (node) {
+      nodes.push(node);
+    }
+  }
+
+  return nodes;
 }

package/packages/knowledge-graph/src/provenance-linker.ts

@@ -4,102 +4,98 @@
  * Provenance linking between skills, RFCs, and implementations.
  */
 
-import type { KnowledgeNode, KnowledgeEdge, KnowledgeGraph } from "./types.js";
+import type { KnowledgeNode, KnowledgeEdge, KnowledgeGraph } from './types.js';
 
 /**
  * Build provenance edges based on metadata
  */
 export function buildProvenanceEdges(graph: KnowledgeGraph): KnowledgeEdge[] {
-	const edges: KnowledgeEdge[] = [];
-	const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+  const edges: KnowledgeEdge[] = [];
+  const nodeMap = new Map(graph.nodes.map(n => [n.id, n]));
 
-	for (const node of graph.nodes) {
-		if (node.type === "skill" && node.data.tags.includes("implements")) {
-			// Link to RFCs found in tags
-			const rfcTag = node.data.tags.find((t) => t.startsWith("rfc-"));
-			if (rfcTag) {
-				edges.push({
-					from: node.id,
-					to: `rfc:${rfcTag.toUpperCase()}`,
-					type: "implements",
-					metadata: { source: "tag:implements" },
-				});
-			}
-		}
+  for (const node of graph.nodes) {
+    if (node.type === 'skill' && node.data.tags.includes('implements')) {
+      // Link to RFCs found in tags
+      const rfcTag = node.data.tags.find(t => t.startsWith('rfc-'));
+      if (rfcTag) {
+        edges.push({
+          from: node.id,
+          to: `rfc:${rfcTag.toUpperCase()}`,
+          type: 'implements',
+          metadata: { source: 'tag:implements' },
+        });
+      }
+    }
 
-		// Implementation -> documents -> RFC
-		if (node.type === "implementation") {
-			const rfcMatch = node.id.match(/implementation:RFC-(\d+)/i);
-			if (rfcMatch) {
-				edges.push({
-					from: node.id,
-					to: `rfc:RFC-${rfcMatch[1].padStart(4, "0")}`,
-					type: "documents",
-					metadata: { source: "id:parsing" },
-				});
-			}
-		}
-	}
+    // Implementation -> documents -> RFC
+    if (node.type === 'implementation') {
+      const rfcMatch = node.id.match(/implementation:RFC-(\d+)/i);
+      if (rfcMatch) {
+        edges.push({
+          from: node.id,
+          to: `rfc:RFC-${rfcMatch[1].padStart(4, '0')}`,
+          type: 'documents',
+          metadata: { source: 'id:parsing' },
+        });
+      }
+    }
+  }
 
-	return edges;
+  return edges;
 }
 
 /**
  * Infer additional edges from content analysis
  */
 export function inferRelationships(graph: KnowledgeGraph): KnowledgeEdge[] {
-	const edges: KnowledgeEdge[] = [];
+  const edges: KnowledgeEdge[] = [];
 
-	// Group skills by shared tags
-	const tagGroups = new Map<string, KnowledgeNode[]>();
-	for (const node of graph.nodes) {
-		if (node.type !== "skill") continue;
-		for (const tag of node.data.tags) {
-			if (!tagGroups.has(tag)) {
-				tagGroups.set(tag, []);
-			}
-			tagGroups.get(tag)!.push(node);
-		}
-	}
+  // Group skills by shared tags
+  const tagGroups = new Map<string, KnowledgeNode[]>();
+  for (const node of graph.nodes) {
+    if (node.type !== 'skill') continue;
+    for (const tag of node.data.tags) {
+      if (!tagGroups.has(tag)) {
+        tagGroups.set(tag, []);
+      }
+      tagGroups.get(tag)!.push(node);
+    }
+  }
 
-	// Skills sharing 3+ tags are related
-	for (const [, nodes] of tagGroups) {
-		if (nodes.length < 2) continue;
+  // Skills sharing 3+ tags are related
+  for (const [, nodes] of tagGroups) {
+    if (nodes.length < 2) continue;
 
-		for (let i = 0; i < nodes.length; i++) {
-			for (let j = i + 1; j < nodes.length; j++) {
-				const sharedTags = nodes[i].data.tags.filter((t) =>
-					nodes[j].data.tags.includes(t),
-				);
-				if (sharedTags.length >= 3) {
-					edges.push({
-						from: nodes[i].id,
-						to: nodes[j].id,
-						type: "related_to",
-						metadata: {
-							source: "inferred:shared-tags",
-							confidence:
-								sharedTags.length /
-								Math.max(nodes[i].data.tags.length, nodes[j].data.tags.length),
-						},
-					});
-				}
-			}
-		}
-	}
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const sharedTags = nodes[i].data.tags.filter(t => nodes[j].data.tags.includes(t));
+        if (sharedTags.length >= 3) {
+          edges.push({
+            from: nodes[i].id,
+            to: nodes[j].id,
+            type: 'related_to',
+            metadata: {
+              source: 'inferred:shared-tags',
+              confidence: sharedTags.length / Math.max(nodes[i].data.tags.length, nodes[j].data.tags.length),
+            },
+          });
+        }
+      }
+    }
+  }
 
-	return edges;
+  return edges;
 }
 
 /**
  * Complete graph with all provenance links
  */
 export function completeGraph(graph: KnowledgeGraph): KnowledgeGraph {
-	const provenanceEdges = buildProvenanceEdges(graph);
-	const inferredEdges = inferRelationships(graph);
+  const provenanceEdges = buildProvenanceEdges(graph);
+  const inferredEdges = inferRelationships(graph);
 
-	return {
-		nodes: graph.nodes,
-		edges: [...graph.edges, ...provenanceEdges, ...inferredEdges],
-	};
+  return {
+    nodes: graph.nodes,
+    edges: [...graph.edges, ...provenanceEdges, ...inferredEdges],
+  };
 }