@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/ReverseEvidenceGraph-Dlsk94LC.mjs

@@ -0,0 +1,269 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+//#region src/server/evidence/ReverseEvidenceGraph.ts
+var ReverseEvidenceGraph_exports = /* @__PURE__ */ __exportAll({ ReverseEvidenceGraph: () => ReverseEvidenceGraph });
+let nextId = 1;
+function generateId(prefix) {
+	return `${prefix}-${nextId++}`;
+}
+var ReverseEvidenceGraph = class {
+	nodes = /* @__PURE__ */ new Map();
+	edges = /* @__PURE__ */ new Map();
+	eventBus;
+	isDirty = false;
+	mutationSeq = 0;
+	lastPersistedSeq = 0;
+	persistNotifier;
+	setEventBus(eventBus) {
+		this.eventBus = eventBus;
+	}
+	setPersistNotifier(notify) {
+		this.persistNotifier = notify;
+	}
+	markDirty() {
+		this.isDirty = true;
+		this.mutationSeq++;
+		this.persistNotifier?.();
+	}
+	commit() {
+		if (this.isDirty && this.eventBus) {
+			this.isDirty = false;
+			this.eventBus.emit("evidence:updated", {
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				reason: "Tool execution committed changes"
+			});
+		}
+	}
+	/** Add a node to the graph. */
+	addNode(type, label, metadata = {}) {
+		const node = {
+			id: generateId(type),
+			type,
+			label,
+			metadata,
+			createdAt: Date.now()
+		};
+		this.nodes.set(node.id, node);
+		this.markDirty();
+		return node;
+	}
+	/** Add a directed edge between two nodes. */
+	addEdge(sourceId, targetId, type, metadata) {
+		if (!this.nodes.has(sourceId)) throw new Error(`Source node "${sourceId}" not found`);
+		if (!this.nodes.has(targetId)) throw new Error(`Target node "${targetId}" not found`);
+		const edge = {
+			id: generateId("edge"),
+			source: sourceId,
+			target: targetId,
+			type,
+			metadata
+		};
+		this.edges.set(edge.id, edge);
+		this.markDirty();
+		return edge;
+	}
+	/** Get a node by ID. */
+	getNode(id) {
+		return this.nodes.get(id);
+	}
+	/** Remove a node and all connected edges. */
+	removeNode(id) {
+		if (!this.nodes.has(id)) return false;
+		this.nodes.delete(id);
+		for (const [edgeId, edge] of this.edges) if (edge.source === id || edge.target === id) this.edges.delete(edgeId);
+		this.markDirty();
+		return true;
+	}
+	/** Get all edges originating from a node. */
+	getEdgesFrom(nodeId) {
+		return [...this.edges.values()].filter((e) => e.source === nodeId);
+	}
+	/** Get all edges pointing to a node. */
+	getEdgesTo(nodeId) {
+		return [...this.edges.values()].filter((e) => e.target === nodeId);
+	}
+	/** Get total node count. */
+	get nodeCount() {
+		return this.nodes.size;
+	}
+	/** Get total edge count. */
+	get edgeCount() {
+		return this.edges.size;
+	}
+	/**
+	* BFS traversal from a node, following edges in the given direction.
+	* Returns all reachable nodes (including the start node).
+	*/
+	getEvidenceChain(nodeId, direction = "forward") {
+		if (!this.nodes.get(nodeId)) return [];
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [nodeId];
+		const result = [];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (visited.has(current)) continue;
+			visited.add(current);
+			const node = this.nodes.get(current);
+			if (node) result.push(node);
+			const connectedEdges = direction === "forward" ? this.getEdgesFrom(current) : this.getEdgesTo(current);
+			for (const edge of connectedEdges) {
+				const nextNodeId = direction === "forward" ? edge.target : edge.source;
+				if (!visited.has(nextNodeId)) queue.push(nextNodeId);
+			}
+		}
+		return result;
+	}
+	/**
+	* Find all nodes associated with a URL.
+	* Searches request nodes by URL metadata, then returns connected subgraph.
+	*/
+	queryByUrl(url) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "request" && typeof n.metadata.url === "string") return n.metadata.url.includes(url);
+			if (typeof n.metadata.url === "string") return n.metadata.url.includes(url);
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/**
+	* Find all nodes associated with a function name.
+	* Searches function nodes, then returns connected subgraph.
+	*/
+	queryByFunction(name) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "function" && typeof n.metadata.functionName === "string") return n.metadata.functionName.includes(name);
+			if (n.label.includes(name) && (n.type === "function" || n.type === "breakpoint-hook")) return true;
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/**
+	* Find all nodes associated with a script ID.
+	* Searches script nodes by scriptId metadata, then returns connected subgraph.
+	*/
+	queryByScriptId(scriptId) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "script" && n.metadata.scriptId === scriptId) return true;
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/** Export the full graph as a JSON snapshot. */
+	exportJson() {
+		return {
+			version: 1,
+			nodes: [...this.nodes.values()],
+			edges: [...this.edges.values()],
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	/** Export the graph as a readable Markdown report. */
+	exportMarkdown() {
+		const lines = [];
+		lines.push("# Reverse Evidence Graph Report");
+		lines.push("");
+		lines.push(`**Exported:** ${(/* @__PURE__ */ new Date()).toISOString()}`);
+		lines.push(`**Nodes:** ${this.nodes.size} | **Edges:** ${this.edges.size}`);
+		lines.push("");
+		const byType = /* @__PURE__ */ new Map();
+		for (const node of this.nodes.values()) {
+			const list = byType.get(node.type) ?? [];
+			list.push(node);
+			byType.set(node.type, list);
+		}
+		for (const type of [
+			"request",
+			"initiator-stack",
+			"script",
+			"function",
+			"breakpoint-hook",
+			"captured-data",
+			"replay-artifact",
+			"v8-heap-object",
+			"v8-hidden-class",
+			"network-request",
+			"network-response",
+			"canvas-scene-node",
+			"canvas-render-node",
+			"skia-draw-call",
+			"syscall-event",
+			"mojo-message",
+			"mojo-interface",
+			"binary-symbol",
+			"binary-function",
+			"binary-module",
+			"proto-message",
+			"proto-state"
+		]) {
+			const nodes = byType.get(type);
+			if (!nodes || nodes.length === 0) continue;
+			lines.push(`## ${type} (${nodes.length})`);
+			lines.push("");
+			for (const node of nodes) {
+				lines.push(`### ${node.label}`);
+				lines.push(`- **ID:** \`${node.id}\``);
+				lines.push(`- **Created:** ${new Date(node.createdAt).toISOString()}`);
+				const metaKeys = Object.keys(node.metadata);
+				if (metaKeys.length > 0) for (const key of metaKeys) {
+					const val = node.metadata[key];
+					const display = typeof val === "string" ? val : JSON.stringify(val);
+					lines.push(`- **${key}:** ${display}`);
+				}
+				const outEdges = this.getEdgesFrom(node.id);
+				const inEdges = this.getEdgesTo(node.id);
+				if (outEdges.length > 0) lines.push(`- **→ Out:** ${outEdges.map((e) => `${e.type} → \`${e.target}\``).join(", ")}`);
+				if (inEdges.length > 0) lines.push(`- **← In:** ${inEdges.map((e) => `\`${e.source}\` ${e.type} →`).join(", ")}`);
+				lines.push("");
+			}
+		}
+		return lines.join("\n");
+	}
+	getSnapshotSeq() {
+		return this.mutationSeq;
+	}
+	getLastPersistedSeq() {
+		return this.lastPersistedSeq;
+	}
+	markPersisted() {
+		this.lastPersistedSeq = this.mutationSeq;
+	}
+	isPersistDirty() {
+		return this.mutationSeq !== this.lastPersistedSeq;
+	}
+	exportSnapshot() {
+		return {
+			schemaVersion: 1,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			graph: this.exportJson()
+		};
+	}
+	restoreSnapshot(data) {
+		if (!data || typeof data !== "object") return;
+		const snapshot = data;
+		if (snapshot.schemaVersion !== 1 || !snapshot.graph) return;
+		const { nodes, edges } = snapshot.graph;
+		this.nodes.clear();
+		this.edges.clear();
+		for (const node of nodes) this.nodes.set(node.id, node);
+		for (const edge of edges) this.edges.set(edge.id, edge);
+		this.mutationSeq = nodes.length + edges.length;
+		this.lastPersistedSeq = this.mutationSeq;
+		this.isDirty = false;
+	}
+};
+//#endregion
+export { ReverseEvidenceGraph_exports as t };