hive-rank 3.0.0

package/dist/hooks/capture-seo-data.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../shared/dist/types.js
+var init_types = __esm({
+  "../shared/dist/types.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/anonymize.js
+import crypto from "crypto";
+function hashContributorId(uuid) {
+  return crypto.createHash("sha256").update(uuid).digest("hex");
+}
+function bucketTimestamp(isoTimestamp) {
+  const date = new Date(isoTimestamp);
+  if (isNaN(date.getTime())) {
+    const match = isoTimestamp.match(/^(\d{4}-\d{2}-\d{2})/);
+    if (match)
+      return match[1];
+    throw new Error(`Invalid timestamp: ${isoTimestamp}`);
+  }
+  return date.toISOString().slice(0, 10);
+}
+function anonymizeSearchData(contributorId, query, timestamp, results) {
+  return {
+    contributorHash: hashContributorId(contributorId),
+    type: "search",
+    query,
+    observedDate: bucketTimestamp(timestamp),
+    results: results.map((r) => ({
+      url: r.url,
+      position: r.position,
+      title: r.title ?? null,
+      snippet: r.snippet ?? null
+    }))
+  };
+}
+function anonymizeFetchData(contributorId, url, timestamp, title, description, h1, links) {
+  return {
+    contributorHash: hashContributorId(contributorId),
+    type: "fetch",
+    url,
+    observedDate: bucketTimestamp(timestamp),
+    title: title ?? null,
+    description: description ?? null,
+    h1: h1 ?? null,
+    outboundLinks: links ? links.slice(0, MAX_OUTBOUND_LINKS) : null
+  };
+}
+var MAX_OUTBOUND_LINKS;
+var init_anonymize = __esm({
+  "../shared/dist/anonymize.js"() {
+    "use strict";
+    MAX_OUTBOUND_LINKS = 100;
+  }
+});
+
+// ../shared/dist/normalize.js
+var init_normalize = __esm({
+  "../shared/dist/normalize.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/validation.js
+var init_validation = __esm({
+  "../shared/dist/validation.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    init_types();
+    init_anonymize();
+    init_normalize();
+    init_validation();
+  }
+});
+
+// src/hive/client.ts
+var client_exports = {};
+__export(client_exports, {
+  contributeToHive: () => contributeToHive
+});
+async function contributeToHive(hiveConfig, toolName, toolInput, parsedResponse) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let contribution;
+  if (toolName === "WebSearch") {
+    const searchResponse = parsedResponse;
+    const query = toolInput.query;
+    contribution = anonymizeSearchData(
+      hiveConfig.contributorId,
+      query,
+      timestamp,
+      searchResponse.results.map((r, index) => ({
+        url: r.url,
+        position: index + 1,
+        title: r.title ?? null,
+        snippet: r.snippet ?? null
+      }))
+    );
+  } else {
+    const fetchResponse = parsedResponse;
+    const url = toolInput.url;
+    contribution = anonymizeFetchData(
+      hiveConfig.contributorId,
+      url,
+      timestamp,
+      fetchResponse.title ?? null,
+      fetchResponse.description ?? null,
+      fetchResponse.h1Tags ?? null,
+      fetchResponse.links ?? null
+    );
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 8e3);
+  try {
+    const response = await fetch(hiveConfig.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(contribution),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      let body = "";
+      try {
+        body = await response.text();
+      } catch {
+      }
+      throw new Error(
+        `Hive contribution failed: HTTP ${response.status}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
+      );
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+var init_client = __esm({
+  "src/hive/client.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// hooks/capture-seo-data.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var DEBUG_LOG = "/tmp/hive-rank-hook-debug.log";
+function debugLog(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  fs.appendFileSync(DEBUG_LOG, `[${timestamp}] ${message}
+`);
+}
+var LOCK_DIR = path.join(os.tmpdir(), "hive-rank-hook-locks");
+function acquireLock(toolUseId) {
+  try {
+    fs.mkdirSync(LOCK_DIR, { recursive: true });
+  } catch {
+    return true;
+  }
+  const lockFile = path.join(LOCK_DIR, `${toolUseId}.lock`);
+  try {
+    const stat = fs.statSync(lockFile);
+    if (Date.now() - stat.mtimeMs < 6e4) return false;
+  } catch {
+  }
+  try {
+    fs.writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    try {
+      const stat = fs.statSync(lockFile);
+      if (Date.now() - stat.mtimeMs < 6e4) return false;
+      fs.writeFileSync(lockFile, String(process.pid));
+      return true;
+    } catch {
+      return true;
+    }
+  }
+}
+function releaseLock(toolUseId) {
+  try {
+    fs.unlinkSync(path.join(LOCK_DIR, `${toolUseId}.lock`));
+  } catch {
+  }
+}
+function cleanStaleLocks() {
+  try {
+    const files = fs.readdirSync(LOCK_DIR);
+    const now = Date.now();
+    for (const file of files) {
+      if (!file.endsWith(".lock")) continue;
+      try {
+        const filePath = path.join(LOCK_DIR, file);
+        const stat = fs.statSync(filePath);
+        if (now - stat.mtimeMs > 6e4) fs.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var DEFAULT_CONFIG = {
+  enabled: true,
+  endpoint: "https://mcp.hive-rank.com/api/contribute",
+  contributorId: null
+};
+function loadConfig() {
+  const configPath = path.join(__dirname, "config.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const userConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      return { ...DEFAULT_CONFIG, ...userConfig };
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+  return DEFAULT_CONFIG;
+}
+function parseWebSearchResponse(response) {
+  if (response == null || typeof response === "boolean" || typeof response === "number") {
+    return { results: [] };
+  }
+  const results = [];
+  if (typeof response === "object") {
+    const structuredResponse = response;
+    if (structuredResponse.results && Array.isArray(structuredResponse.results)) {
+      for (const resultGroup of structuredResponse.results) {
+        if (!resultGroup?.content || !Array.isArray(resultGroup.content)) continue;
+        for (const item of resultGroup.content) {
+          if (typeof item?.url !== "string") continue;
+          if (item.url.startsWith("http://") || item.url.startsWith("https://")) {
+            results.push({
+              url: item.url,
+              title: typeof item.title === "string" ? item.title : void 0
+            });
+          }
+        }
+      }
+    }
+    return { results };
+  }
+  const responseStr = String(response);
+  const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+  let match;
+  while ((match = linkPattern.exec(responseStr)) !== null) {
+    const [, title, url] = match;
+    if (!url.startsWith("http://") && !url.startsWith("https://")) continue;
+    const afterMatch = responseStr.slice(match.index + match[0].length);
+    const snippetMatch = afterMatch.match(/^\s*\n?([^\n\[]+)/);
+    results.push({
+      url,
+      title: title || void 0,
+      snippet: snippetMatch?.[1]?.trim() || void 0
+    });
+  }
+  return { results };
+}
+function parseWebFetchResponse(response) {
+  const result = {};
+  if (response == null || typeof response === "boolean" || typeof response === "number") {
+    return result;
+  }
+  const responseStr = typeof response === "string" ? response : JSON.stringify(response);
+  let titleMatch = responseStr.match(/\*\*(?:Title|Page Title|Page title)\*?\*?:\s*["\']?([^"'\n]+)["\']?/i);
+  if (titleMatch) {
+    result.title = titleMatch[1].trim();
+  } else {
+    const lines = responseStr.split("\n");
+    for (let i = 0; i < Math.min(lines.length, 10); i++) {
+      const line = lines[i].trim();
+      if (line.match(/^#+\s+(?:page\s+)?(?:analysis|information|content|metadata)/i)) continue;
+      if (line.match(/^#+\s+/)) {
+        result.title = line.replace(/^#+\s+/, "").trim();
+        break;
+      }
+    }
+  }
+  const h1Tags = [];
+  const markdownHeadingPattern = /^#{1,2}\s+(.+)$/gm;
+  let headingMatch;
+  while ((headingMatch = markdownHeadingPattern.exec(responseStr)) !== null) {
+    const h1Text = headingMatch[1].trim();
+    if (h1Text && !h1Tags.includes(h1Text)) h1Tags.push(h1Text);
+  }
+  const h1LabelPattern = /\*\*H1\s*(?:heading|tag)?\*?\*?:\s*["\']?([^"'\n]+)["\']?/gi;
+  let h1Match;
+  while ((h1Match = h1LabelPattern.exec(responseStr)) !== null) {
+    const h1Text = h1Match[1].trim();
+    if (h1Text && !h1Tags.includes(h1Text)) h1Tags.push(h1Text);
+  }
+  if (h1Tags.length > 0) result.h1Tags = h1Tags;
+  const links = [];
+  const urlPattern = /(https?:\/\/[^\s\n\)\]\}]+)/g;
+  let urlMatch;
+  while ((urlMatch = urlPattern.exec(responseStr)) !== null) {
+    let url = urlMatch[1].replace(/[.,;:\)\]\}]*$/, "");
+    if (!links.includes(url)) links.push(url);
+  }
+  if (links.length > 0) result.links = [...new Set(links)];
+  let descMatch = responseStr.match(/\*\*(?:meta\s+)?description\*?\*?:\s*["\']?([^"'\n]+)["\']?/i);
+  if (!descMatch) {
+    descMatch = responseStr.match(/^Description:\s*(.+)$/im);
+  }
+  if (descMatch && descMatch[1].length > 10) {
+    result.description = descMatch[1].trim();
+  }
+  return result;
+}
+async function main() {
+  debugLog("Hook started");
+  const stdinPromise = new Promise((resolve) => {
+    const chunks = [];
+    const timeout = setTimeout(() => resolve(""), 5e3);
+    if (process.stdin.isTTY) {
+      clearTimeout(timeout);
+      resolve("");
+      return;
+    }
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      resolve(chunks.join(""));
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timeout);
+      resolve("");
+    });
+  });
+  const inputData = await stdinPromise;
+  if (!inputData) {
+    debugLog("No input data");
+    process.exit(0);
+  }
+  const config = loadConfig();
+  if (!config.enabled || !config.contributorId) {
+    debugLog("Hook disabled or no contributorId");
+    process.exit(0);
+  }
+  let hookInput;
+  try {
+    hookInput = JSON.parse(inputData);
+  } catch {
+    debugLog("Invalid JSON input");
+    process.exit(0);
+  }
+  const { tool_name, tool_input, tool_response, tool_use_id } = hookInput;
+  if (tool_name !== "WebSearch" && tool_name !== "WebFetch") {
+    process.exit(0);
+  }
+  if (tool_use_id && !acquireLock(tool_use_id)) {
+    debugLog("Duplicate invocation, skipping");
+    process.exit(0);
+  }
+  cleanStaleLocks();
+  if (!tool_response || !tool_input || typeof tool_input !== "object") {
+    if (tool_use_id) releaseLock(tool_use_id);
+    process.exit(0);
+  }
+  try {
+    let parsedResponse;
+    if (tool_name === "WebSearch") {
+      parsedResponse = parseWebSearchResponse(tool_response);
+      const results = parsedResponse.results;
+      debugLog(`Parsed ${results.length} search results`);
+      if (results.length === 0) {
+        if (tool_use_id) releaseLock(tool_use_id);
+        process.exit(0);
+      }
+    } else {
+      parsedResponse = parseWebFetchResponse(tool_response);
+      debugLog(`Parsed WebFetch response`);
+    }
+    const { contributeToHive: contributeToHive2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+    await contributeToHive2(
+      { enabled: true, endpoint: config.endpoint, contributorId: config.contributorId },
+      tool_name,
+      tool_input,
+      parsedResponse
+    );
+    debugLog("Contribution sent");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    debugLog(`Error: ${errorMsg}`);
+  }
+  if (tool_use_id) releaseLock(tool_use_id);
+  process.exit(0);
+}
+main().catch((error) => {
+  console.error("[hive-rank] Fatal error:", error);
+  process.exit(1);
+});
+export {
+  acquireLock,
+  cleanStaleLocks,
+  loadConfig,
+  parseWebFetchResponse,
+  parseWebSearchResponse,
+  releaseLock
+};

package/dist/hooks/config.json

@@ -0,0 +1,5 @@
+{
+  "enabled": true,
+  "endpoint": "https://mcp.hive-rank.com/api/contribute",
+  "contributorId": null
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "hive-rank",
+  "version": "3.0.0",
+  "description": "Crowdsourced SEO intelligence for AI agents. Network-powered hooks contribute data to the hive. 6 hive_* tools via remote MCP server.",
+  "author": "hive-rank",
+  "license": "MIT",
+  "homepage": "https://hive-rank.com",
+  "keywords": [
+    "seo",
+    "mcp",
+    "claude",
+    "ai-agent",
+    "rankings",
+    "search",
+    "serp",
+    "model-context-protocol"
+  ],
+  "type": "module",
+  "bin": {
+    "hive-rank": "bin/install.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "commands"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "node scripts/build-hooks.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@gys-hive/shared": "workspace:*",
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.24.2",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  }
+}