733 lines
23 KiB
JavaScript
733 lines
23 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const { extractFrontmatter, parseSourcesFrontmatter, sortedUnique } = require("./lib/source-signal-eligibility");
|
|
|
|
function readJson(filePath) {
|
|
return JSON.parse(fs.readFileSync(filePath, "utf8"));
|
|
}
|
|
|
|
function writeJson(filePath, value) {
|
|
fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
function roundNumber(value, digits = 3) {
|
|
const factor = 10 ** digits;
|
|
return Math.round(value * factor) / factor;
|
|
}
|
|
|
|
function clamp01(value) {
|
|
return Math.max(0, Math.min(1, value));
|
|
}
|
|
|
|
function sortedPairKey(a, b) {
|
|
return a < b ? `${a}\t${b}` : `${b}\t${a}`;
|
|
}
|
|
|
|
function normalizeBody(text, degraded, maxLines) {
|
|
const { body } = extractFrontmatter(text);
|
|
const normalized = body.replace(/^\s+/, "").replace(/\s+$/, "");
|
|
if (!degraded) return normalized;
|
|
return normalized.split(/\r?\n/).slice(0, maxLines).join("\n").replace(/\s+$/, "");
|
|
}
|
|
|
|
function loadNodeDetails(nodes, degraded, maxLines) {
|
|
const byId = {};
|
|
|
|
for (const node of nodes) {
|
|
const filePath = node._file_path || node.source_path;
|
|
const raw = fs.readFileSync(filePath, "utf8");
|
|
const frontmatter = extractFrontmatter(raw);
|
|
const parsedSources = parseSourcesFrontmatter(frontmatter.frontmatter);
|
|
const normalizedNode = {
|
|
...node,
|
|
content: normalizeBody(raw, degraded, maxLines),
|
|
_signals: {
|
|
sources: parsedSources.sources,
|
|
sourceSignalAvailable: parsedSources.signalAvailable,
|
|
sourceFieldPresent: parsedSources.hasField,
|
|
sourceFieldParsed: parsedSources.parsed
|
|
}
|
|
};
|
|
byId[node.id] = normalizedNode;
|
|
}
|
|
|
|
return byId;
|
|
}
|
|
|
|
function buildInlinks(edges) {
|
|
const inlinks = new Map();
|
|
|
|
for (const edge of edges) {
|
|
if (!inlinks.has(edge.to)) inlinks.set(edge.to, new Set());
|
|
inlinks.get(edge.to).add(edge.from);
|
|
}
|
|
|
|
return inlinks;
|
|
}
|
|
|
|
function intersectionCount(setA, setB) {
|
|
if (!setA || !setB) return 0;
|
|
let small = setA;
|
|
let large = setB;
|
|
if (setB.size < setA.size) {
|
|
small = setB;
|
|
large = setA;
|
|
}
|
|
|
|
let count = 0;
|
|
for (const value of small) {
|
|
if (large.has(value)) count += 1;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
function typeAffinity(typeA, typeB) {
|
|
const pair = [typeA || "other", typeB || "other"].sort().join(":");
|
|
switch (pair) {
|
|
case "entity:entity":
|
|
case "entity:topic":
|
|
return 1;
|
|
case "topic:topic":
|
|
return 0.8;
|
|
case "entity:source":
|
|
return 0.6;
|
|
case "source:source":
|
|
return 0.3;
|
|
default:
|
|
return 0.5;
|
|
}
|
|
}
|
|
|
|
function computePairMetrics(nodesById, edges) {
|
|
const inlinks = buildInlinks(edges);
|
|
const pairMetrics = new Map();
|
|
|
|
for (const edge of edges) {
|
|
const pairKey = sortedPairKey(edge.from, edge.to);
|
|
if (pairMetrics.has(pairKey)) continue;
|
|
|
|
const fromNode = nodesById[edge.from];
|
|
const toNode = nodesById[edge.to];
|
|
if (!fromNode || !toNode) continue;
|
|
|
|
const fromInlinks = inlinks.get(edge.from) || new Set();
|
|
const toInlinks = inlinks.get(edge.to) || new Set();
|
|
const sharedInlinks = intersectionCount(fromInlinks, toInlinks);
|
|
const coCitation = sharedInlinks / Math.max(fromInlinks.size, toInlinks.size, 1);
|
|
const affinity = typeAffinity(fromNode.type, toNode.type);
|
|
|
|
const signals = [coCitation, affinity];
|
|
let sourceOverlap = null;
|
|
const sourceSignalAvailable = Boolean(
|
|
fromNode._signals.sourceSignalAvailable && toNode._signals.sourceSignalAvailable
|
|
);
|
|
|
|
if (sourceSignalAvailable) {
|
|
const fromSources = new Set(fromNode._signals.sources);
|
|
const toSources = new Set(toNode._signals.sources);
|
|
const overlap = intersectionCount(fromSources, toSources);
|
|
const minSize = Math.min(fromSources.size, toSources.size);
|
|
sourceOverlap = minSize > 0 ? overlap / minSize : 0;
|
|
signals.push(sourceOverlap);
|
|
}
|
|
|
|
const weight = clamp01(signals.reduce((sum, value) => sum + value, 0) / signals.length);
|
|
|
|
pairMetrics.set(pairKey, {
|
|
weight: roundNumber(weight),
|
|
signals: {
|
|
co_citation: roundNumber(coCitation),
|
|
source_overlap: sourceOverlap == null ? null : roundNumber(sourceOverlap),
|
|
type_affinity: roundNumber(affinity)
|
|
},
|
|
source_signal_available: sourceSignalAvailable
|
|
});
|
|
}
|
|
|
|
return pairMetrics;
|
|
}
|
|
|
|
function buildUndirectedGraph(nodeIds, pairMetrics) {
|
|
const adjacency = new Map();
|
|
const degrees = new Map();
|
|
|
|
for (const nodeId of nodeIds) {
|
|
adjacency.set(nodeId, new Map());
|
|
degrees.set(nodeId, 0);
|
|
}
|
|
|
|
for (const [pairKey, metrics] of pairMetrics.entries()) {
|
|
const [left, right] = pairKey.split("\t");
|
|
if (!adjacency.has(left) || !adjacency.has(right)) continue;
|
|
const weight = metrics.weight;
|
|
adjacency.get(left).set(right, weight);
|
|
adjacency.get(right).set(left, weight);
|
|
degrees.set(left, degrees.get(left) + weight);
|
|
degrees.set(right, degrees.get(right) + weight);
|
|
}
|
|
|
|
return { adjacency, degrees };
|
|
}
|
|
|
|
function runLocalMove(graph) {
|
|
const nodes = Array.from(graph.nodes.keys()).sort();
|
|
const communities = new Map();
|
|
const totals = new Map();
|
|
let moved = false;
|
|
|
|
for (const nodeId of nodes) {
|
|
communities.set(nodeId, nodeId);
|
|
totals.set(nodeId, graph.degrees.get(nodeId) || 0);
|
|
}
|
|
|
|
if (graph.m2 === 0) {
|
|
return { communities, changed: false };
|
|
}
|
|
|
|
let changedInPass = true;
|
|
let passCount = 0;
|
|
while (changedInPass && passCount < 50) {
|
|
passCount++;
|
|
changedInPass = false;
|
|
|
|
for (const nodeId of nodes) {
|
|
const degree = graph.degrees.get(nodeId) || 0;
|
|
const currentCommunity = communities.get(nodeId);
|
|
const neighborCommunities = new Map();
|
|
|
|
for (const [neighborId, weight] of graph.nodes.get(nodeId).entries()) {
|
|
const communityId = communities.get(neighborId);
|
|
neighborCommunities.set(communityId, (neighborCommunities.get(communityId) || 0) + weight);
|
|
}
|
|
|
|
totals.set(currentCommunity, (totals.get(currentCommunity) || 0) - degree);
|
|
if ((neighborCommunities.get(currentCommunity) || 0) === 0) {
|
|
neighborCommunities.set(currentCommunity, 0);
|
|
}
|
|
|
|
let bestCommunity = currentCommunity;
|
|
let bestGain = 0;
|
|
|
|
const candidates = Array.from(neighborCommunities.keys()).sort();
|
|
for (const communityId of candidates) {
|
|
const inWeight = neighborCommunities.get(communityId) || 0;
|
|
const gain = inWeight - ((totals.get(communityId) || 0) * degree) / graph.m2;
|
|
if (gain > bestGain + 1e-9) {
|
|
bestGain = gain;
|
|
bestCommunity = communityId;
|
|
}
|
|
}
|
|
|
|
communities.set(nodeId, bestCommunity);
|
|
totals.set(bestCommunity, (totals.get(bestCommunity) || 0) + degree);
|
|
|
|
if (bestCommunity !== currentCommunity) {
|
|
changedInPass = true;
|
|
moved = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return { communities, changed: moved };
|
|
}
|
|
|
|
function aggregateGraph(graph, communities) {
|
|
const communityIds = sortedUnique(Array.from(communities.values()));
|
|
const aggregatedNodes = new Map();
|
|
const aggregatedDegrees = new Map();
|
|
const members = new Map();
|
|
|
|
for (const communityId of communityIds) {
|
|
aggregatedNodes.set(communityId, new Map());
|
|
aggregatedDegrees.set(communityId, 0);
|
|
members.set(communityId, []);
|
|
}
|
|
|
|
for (const [nodeId, communityId] of communities.entries()) {
|
|
members.get(communityId).push(...(graph.members.get(nodeId) || [nodeId]));
|
|
}
|
|
|
|
for (const [nodeId, neighbors] of graph.nodes.entries()) {
|
|
const sourceCommunity = communities.get(nodeId);
|
|
for (const [neighborId, weight] of neighbors.entries()) {
|
|
if (nodeId > neighborId) continue;
|
|
const targetCommunity = communities.get(neighborId);
|
|
const current = aggregatedNodes.get(sourceCommunity).get(targetCommunity) || 0;
|
|
aggregatedNodes.get(sourceCommunity).set(targetCommunity, current + weight);
|
|
if (sourceCommunity !== targetCommunity) {
|
|
const mirrored = aggregatedNodes.get(targetCommunity).get(sourceCommunity) || 0;
|
|
aggregatedNodes.get(targetCommunity).set(sourceCommunity, mirrored + weight);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const [communityId, neighbors] of aggregatedNodes.entries()) {
|
|
let degree = 0;
|
|
for (const [neighborId, weight] of neighbors.entries()) {
|
|
degree += neighborId === communityId ? weight * 2 : weight;
|
|
}
|
|
aggregatedDegrees.set(communityId, degree);
|
|
}
|
|
|
|
return {
|
|
nodes: aggregatedNodes,
|
|
degrees: aggregatedDegrees,
|
|
members,
|
|
m2: Array.from(aggregatedDegrees.values()).reduce((sum, value) => sum + value, 0)
|
|
};
|
|
}
|
|
|
|
function runLouvain(nodeIds, pairMetrics) {
|
|
const baseGraph = buildUndirectedGraph(nodeIds, pairMetrics);
|
|
let graph = {
|
|
nodes: baseGraph.adjacency,
|
|
degrees: baseGraph.degrees,
|
|
members: new Map(nodeIds.map((nodeId) => [nodeId, [nodeId]])),
|
|
m2: Array.from(baseGraph.degrees.values()).reduce((sum, value) => sum + value, 0)
|
|
};
|
|
|
|
let bestMembers = graph.members;
|
|
|
|
while (true) {
|
|
const phase = runLocalMove(graph);
|
|
const nextGraph = aggregateGraph(graph, phase.communities);
|
|
bestMembers = nextGraph.members;
|
|
|
|
if (!phase.changed || nextGraph.nodes.size === graph.nodes.size) {
|
|
break;
|
|
}
|
|
|
|
graph = nextGraph;
|
|
}
|
|
|
|
const finalCommunities = new Map();
|
|
for (const [communityId, members] of bestMembers.entries()) {
|
|
for (const nodeId of members) {
|
|
finalCommunities.set(nodeId, communityId);
|
|
}
|
|
}
|
|
|
|
return finalCommunities;
|
|
}
|
|
|
|
function buildDirectedDegree(edges) {
|
|
const degree = new Map();
|
|
for (const edge of edges) {
|
|
degree.set(edge.from, (degree.get(edge.from) || 0) + 1);
|
|
degree.set(edge.to, (degree.get(edge.to) || 0) + 1);
|
|
}
|
|
return degree;
|
|
}
|
|
|
|
function chooseCommunityLabels(nodeIds, communityAssignments, nodesById, edges) {
|
|
const groups = new Map();
|
|
const degree = buildDirectedDegree(edges);
|
|
|
|
for (const nodeId of nodeIds) {
|
|
const communityId = communityAssignments.get(nodeId) || nodeId;
|
|
if (!groups.has(communityId)) groups.set(communityId, []);
|
|
groups.get(communityId).push(nodeId);
|
|
}
|
|
|
|
const labeledAssignments = new Map();
|
|
|
|
for (const members of groups.values()) {
|
|
members.sort();
|
|
if (members.length === 1) {
|
|
labeledAssignments.set(members[0], null);
|
|
continue;
|
|
}
|
|
|
|
const memberNodes = members.map((memberId) => nodesById[memberId]);
|
|
const topics = memberNodes.filter((node) => node && node.type === "topic");
|
|
const candidates = topics.length ? topics : memberNodes;
|
|
candidates.sort((left, right) => {
|
|
const degreeDiff = (degree.get(right.id) || 0) - (degree.get(left.id) || 0);
|
|
if (degreeDiff !== 0) return degreeDiff;
|
|
return left.id.localeCompare(right.id);
|
|
});
|
|
|
|
const label = candidates[0] ? candidates[0].id : members[0];
|
|
for (const memberId of members) {
|
|
labeledAssignments.set(memberId, label);
|
|
}
|
|
}
|
|
|
|
return labeledAssignments;
|
|
}
|
|
|
|
function buildInsights(nodesById, edges, pairMetrics, communityAssignments, options) {
|
|
const directedDegree = buildDirectedDegree(edges);
|
|
const undirectedPairs = new Map();
|
|
const adjacency = new Map();
|
|
|
|
for (const nodeId of Object.keys(nodesById)) {
|
|
adjacency.set(nodeId, new Set());
|
|
}
|
|
|
|
for (const edge of edges) {
|
|
const pairKey = sortedPairKey(edge.from, edge.to);
|
|
if (!undirectedPairs.has(pairKey)) {
|
|
undirectedPairs.set(pairKey, {
|
|
from: pairKey.split("\t")[0],
|
|
to: pairKey.split("\t")[1],
|
|
weight: pairMetrics.get(pairKey)?.weight || 0
|
|
});
|
|
}
|
|
adjacency.get(edge.from)?.add(edge.to);
|
|
adjacency.get(edge.to)?.add(edge.from);
|
|
}
|
|
|
|
const isolatedNodes = Object.values(nodesById)
|
|
.filter((node) => (directedDegree.get(node.id) || 0) <= 1)
|
|
.sort((left, right) => left.id.localeCompare(right.id))
|
|
.map((node) => ({
|
|
id: node.id,
|
|
label: node.label,
|
|
degree: directedDegree.get(node.id) || 0,
|
|
community: communityAssignments.get(node.id) || null
|
|
}));
|
|
|
|
const bridgeNodes = [];
|
|
for (const node of Object.values(nodesById).sort((left, right) => left.id.localeCompare(right.id))) {
|
|
const ownCommunity = communityAssignments.get(node.id) || null;
|
|
const connectedCommunities = sortedUnique(
|
|
Array.from(adjacency.get(node.id) || [])
|
|
.map((neighborId) => communityAssignments.get(neighborId) || null)
|
|
.filter((c) => c && c !== ownCommunity)
|
|
);
|
|
|
|
if (connectedCommunities.length >= 2) {
|
|
bridgeNodes.push({
|
|
id: node.id,
|
|
label: node.label,
|
|
community: ownCommunity,
|
|
connected_communities: connectedCommunities,
|
|
community_count: connectedCommunities.length
|
|
});
|
|
}
|
|
}
|
|
|
|
const communityMembers = new Map();
|
|
for (const node of Object.values(nodesById)) {
|
|
const communityId = communityAssignments.get(node.id) || null;
|
|
if (!communityId) continue;
|
|
if (!communityMembers.has(communityId)) communityMembers.set(communityId, []);
|
|
communityMembers.get(communityId).push(node.id);
|
|
}
|
|
|
|
const sparseCommunities = [];
|
|
for (const [communityId, members] of Array.from(communityMembers.entries()).sort((left, right) => left[0].localeCompare(right[0]))) {
|
|
if (members.length < 3) continue;
|
|
|
|
const memberSet = new Set(members);
|
|
let internalEdges = 0;
|
|
for (const pair of undirectedPairs.values()) {
|
|
if (memberSet.has(pair.from) && memberSet.has(pair.to)) internalEdges += 1;
|
|
}
|
|
|
|
const possibleEdges = (members.length * (members.length - 1)) / 2;
|
|
const density = possibleEdges === 0 ? 0 : internalEdges / possibleEdges;
|
|
if (density < 0.15) {
|
|
sparseCommunities.push({
|
|
id: communityId,
|
|
label: nodesById[communityId]?.label || communityId,
|
|
node_count: members.length,
|
|
density: roundNumber(density),
|
|
members: members.sort(),
|
|
internal_edges: internalEdges
|
|
});
|
|
}
|
|
}
|
|
|
|
const surprisingConnections = Array.from(undirectedPairs.values())
|
|
.filter((pair) => {
|
|
const fromCommunity = communityAssignments.get(pair.from) || null;
|
|
const toCommunity = communityAssignments.get(pair.to) || null;
|
|
return fromCommunity && toCommunity && fromCommunity !== toCommunity && pair.weight >= 0.75;
|
|
})
|
|
.sort((left, right) => {
|
|
if (right.weight !== left.weight) return right.weight - left.weight;
|
|
if (left.from !== right.from) return left.from.localeCompare(right.from);
|
|
return left.to.localeCompare(right.to);
|
|
})
|
|
.slice(0, 8)
|
|
.map((pair) => ({
|
|
from: pair.from,
|
|
to: pair.to,
|
|
weight: pair.weight,
|
|
from_community: communityAssignments.get(pair.from) || null,
|
|
to_community: communityAssignments.get(pair.to) || null
|
|
}));
|
|
|
|
const degraded = options.nodeCount > options.maxInsightNodes || options.edgeCount > options.maxInsightEdges;
|
|
if (degraded) {
|
|
return {
|
|
surprising_connections: [],
|
|
isolated_nodes: isolatedNodes,
|
|
bridge_nodes: [],
|
|
sparse_communities: [],
|
|
meta: {
|
|
degraded: true,
|
|
node_count: options.nodeCount,
|
|
edge_count: options.edgeCount,
|
|
max_insight_nodes: options.maxInsightNodes,
|
|
max_insight_edges: options.maxInsightEdges
|
|
}
|
|
};
|
|
}
|
|
|
|
return {
|
|
surprising_connections: surprisingConnections,
|
|
isolated_nodes: isolatedNodes,
|
|
bridge_nodes: bridgeNodes,
|
|
sparse_communities: sparseCommunities,
|
|
meta: {
|
|
degraded: false,
|
|
node_count: options.nodeCount,
|
|
edge_count: options.edgeCount,
|
|
max_insight_nodes: options.maxInsightNodes,
|
|
max_insight_edges: options.maxInsightEdges
|
|
}
|
|
};
|
|
}
|
|
|
|
function buildLearning(analyzedNodes, analyzedEdges) {
|
|
const degreeMap = new Map();
|
|
for (const edge of analyzedEdges) {
|
|
degreeMap.set(edge.from, (degreeMap.get(edge.from) || 0) + 1);
|
|
degreeMap.set(edge.to, (degreeMap.get(edge.to) || 0) + 1);
|
|
}
|
|
|
|
const communityGroups = new Map();
|
|
for (const node of analyzedNodes) {
|
|
if (node.community == null) continue;
|
|
if (!communityGroups.has(node.community)) communityGroups.set(node.community, []);
|
|
communityGroups.get(node.community).push(node);
|
|
}
|
|
|
|
const communities = [];
|
|
for (const [cid, members] of communityGroups.entries()) {
|
|
const memberIds = new Set(members.map(n => n.id));
|
|
let totalWeight = 0;
|
|
for (const edge of analyzedEdges) {
|
|
if (memberIds.has(edge.from) && memberIds.has(edge.to)) totalWeight += edge.weight;
|
|
}
|
|
const isWeak = members.length < 3;
|
|
const startNode = members.slice().sort((a, b) => {
|
|
const degDiff = (degreeMap.get(b.id) || 0) - (degreeMap.get(a.id) || 0);
|
|
if (degDiff !== 0) return degDiff;
|
|
return a.id.localeCompare(b.id);
|
|
})[0];
|
|
|
|
communities.push({
|
|
id: cid,
|
|
label: (members.find(n => n.id === cid) || members[0]).label,
|
|
node_count: members.length,
|
|
source_count: members.filter(n => n.type === "source").length,
|
|
internal_edge_weight: roundNumber(totalWeight),
|
|
is_primary: false,
|
|
is_weak: isWeak,
|
|
recommended_start_node_id: startNode.id
|
|
});
|
|
}
|
|
|
|
communities.sort((a, b) => {
|
|
if (b.node_count !== a.node_count) return b.node_count - a.node_count;
|
|
if (b.internal_edge_weight !== a.internal_edge_weight) return b.internal_edge_weight - a.internal_edge_weight;
|
|
return a.id.localeCompare(b.id);
|
|
});
|
|
|
|
if (communities.length > 0) communities[0].is_primary = true;
|
|
|
|
const primary = communities.length > 0 ? communities[0] : null;
|
|
const startNodeId = primary ? primary.recommended_start_node_id : null;
|
|
|
|
let pathNodeIds = [];
|
|
let pathDegraded = false;
|
|
if (primary && !primary.is_weak && startNodeId) {
|
|
const primaryMemberIds = new Set(communityGroups.get(primary.id).map(n => n.id));
|
|
const neighbors = analyzedEdges
|
|
.filter(e => (e.from === startNodeId && primaryMemberIds.has(e.to)) ||
|
|
(e.to === startNodeId && primaryMemberIds.has(e.from)))
|
|
.map(e => e.from === startNodeId ? e.to : e.from);
|
|
pathNodeIds = [startNodeId, ...sortedUnique(neighbors).filter(id => id !== startNodeId)];
|
|
if (pathNodeIds.length < 2) pathDegraded = true;
|
|
} else {
|
|
pathDegraded = true;
|
|
}
|
|
|
|
let communityNodeIds = [];
|
|
let communityDegraded = false;
|
|
if (primary && !primary.is_weak) {
|
|
communityNodeIds = communityGroups.get(primary.id).map(n => n.id).sort();
|
|
} else {
|
|
communityDegraded = true;
|
|
}
|
|
|
|
const globalNodeIds = analyzedNodes.slice().sort((a, b) => {
|
|
const degDiff = (degreeMap.get(b.id) || 0) - (degreeMap.get(a.id) || 0);
|
|
if (degDiff !== 0) return degDiff;
|
|
return a.id.localeCompare(b.id);
|
|
}).map(n => n.id);
|
|
|
|
const defaultMode = "global";
|
|
|
|
return {
|
|
version: 1,
|
|
entry: {
|
|
recommended_start_node_id: startNodeId,
|
|
recommended_start_reason: startNodeId ? "community_hub" : null,
|
|
default_mode: defaultMode
|
|
},
|
|
views: {
|
|
path: {
|
|
enabled: !pathDegraded,
|
|
start_node_id: pathDegraded ? null : startNodeId,
|
|
node_ids: pathDegraded ? [] : pathNodeIds,
|
|
degraded: pathDegraded
|
|
},
|
|
community: {
|
|
enabled: !communityDegraded,
|
|
community_id: primary && !communityDegraded ? primary.id : null,
|
|
label: primary && !communityDegraded ? primary.label : null,
|
|
node_ids: communityDegraded ? [] : communityNodeIds,
|
|
is_weak: primary ? primary.is_weak : false,
|
|
degraded: communityDegraded
|
|
},
|
|
global: {
|
|
enabled: true,
|
|
node_ids: globalNodeIds,
|
|
degraded: false
|
|
}
|
|
},
|
|
communities,
|
|
degraded: {
|
|
path_to_community: pathDegraded,
|
|
community_to_global: communityDegraded
|
|
}
|
|
};
|
|
}
|
|
|
|
function analyzeGraph(nodes, edges, options = {}) {
|
|
const degraded = options.degraded === true;
|
|
const maxLines = options.maxLines || 500;
|
|
const maxInsightNodes = options.maxInsightNodes || 250;
|
|
const maxInsightEdges = options.maxInsightEdges || 1000;
|
|
|
|
const nodesById = loadNodeDetails(nodes, degraded, maxLines);
|
|
const pairMetrics = computePairMetrics(nodesById, edges);
|
|
const nodeIds = nodes.map((node) => node.id);
|
|
const communityAssignments = chooseCommunityLabels(
|
|
nodeIds,
|
|
runLouvain(nodeIds, pairMetrics),
|
|
nodesById,
|
|
edges
|
|
);
|
|
|
|
const analyzedNodes = nodes.map((node) => ({
|
|
id: node.id,
|
|
label: node.label,
|
|
type: node.type,
|
|
source_path: node.source_path,
|
|
community: communityAssignments.get(node.id) || null,
|
|
content: nodesById[node.id].content
|
|
}));
|
|
|
|
const analyzedEdges = edges.map((edge) => {
|
|
const pairKey = sortedPairKey(edge.from, edge.to);
|
|
const metrics = pairMetrics.get(pairKey) || {
|
|
weight: 0,
|
|
signals: { co_citation: 0, source_overlap: null, type_affinity: 0.5 },
|
|
source_signal_available: false
|
|
};
|
|
|
|
return {
|
|
id: edge.id,
|
|
from: edge.from,
|
|
to: edge.to,
|
|
type: edge.type,
|
|
confidence: edge.confidence || edge.type,
|
|
relation_type: edge.relation_type || "依赖",
|
|
weight: metrics.weight,
|
|
source_signal_available: metrics.source_signal_available,
|
|
signals: metrics.signals
|
|
};
|
|
});
|
|
|
|
const insights = buildInsights(nodesById, analyzedEdges, pairMetrics, communityAssignments, {
|
|
nodeCount: analyzedNodes.length,
|
|
edgeCount: analyzedEdges.length,
|
|
maxInsightNodes,
|
|
maxInsightEdges
|
|
});
|
|
|
|
const learning = buildLearning(analyzedNodes, analyzedEdges);
|
|
|
|
return { nodes: analyzedNodes, edges: analyzedEdges, insights, learning };
|
|
}
|
|
|
|
function main(argv) {
|
|
if (argv.length < 7) {
|
|
console.error("Usage: node graph-analysis.js <nodes.json> <edges.json> <output.json> <degraded:0|1> <max-lines> <max-insight-nodes> <max-insight-edges>");
|
|
process.exit(1);
|
|
}
|
|
|
|
const timer = setTimeout(() => {
|
|
console.error("ERROR: graph analysis timed out (120s)");
|
|
process.exit(2);
|
|
}, 120_000);
|
|
timer.unref();
|
|
|
|
const [, , nodesPath, edgesPath, outputPath, degradedRaw, maxLinesRaw, maxInsightNodesRaw, maxInsightEdgesRaw] = argv;
|
|
|
|
for (const p of [nodesPath, edgesPath]) {
|
|
if (!fs.existsSync(p)) {
|
|
console.error(`ERROR: File not found: ${p}`);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
const analyzed = analyzeGraph(readJson(nodesPath), readJson(edgesPath), {
|
|
degraded: degradedRaw === "1",
|
|
maxLines: Number(maxLinesRaw) || 500,
|
|
maxInsightNodes: Number(maxInsightNodesRaw) || 250,
|
|
maxInsightEdges: Number(maxInsightEdgesRaw) || 1000
|
|
});
|
|
|
|
writeJson(outputPath, analyzed);
|
|
clearTimeout(timer);
|
|
}
|
|
|
|
if (require.main === module) {
|
|
try {
|
|
main(process.argv);
|
|
} catch (error) {
|
|
const code = error && error.code;
|
|
if (code === "ENOENT") {
|
|
console.error(`ERROR: File not found: ${error.path || "(unknown)"}`);
|
|
} else if (error instanceof SyntaxError) {
|
|
console.error(`ERROR: Invalid JSON in input: ${error.message}`);
|
|
} else {
|
|
console.error(`ERROR: ${error && error.message ? error.message : String(error)}`);
|
|
}
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
analyzeGraph,
|
|
buildInsights,
|
|
buildLearning,
|
|
chooseCommunityLabels,
|
|
computePairMetrics,
|
|
extractFrontmatter,
|
|
normalizeBody,
|
|
parseSourcesFrontmatter,
|
|
runLouvain,
|
|
typeAffinity
|
|
};
|