@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

package/dist/es/standards-sdk.es132.js

@@ -1,205 +1,396 @@
-import axios from "axios";
-import { Logger } from "./standards-sdk.es128.js";
-import { HederaMirrorNode } from "./standards-sdk.es149.js";
-import "buffer";
-import "@noble/curves/secp256k1.js";
-import "zod";
-import "./standards-sdk.es158.js";
-import "./standards-sdk.es152.js";
-import "./standards-sdk.es156.js";
-class HRLResolver {
-  constructor(logLevel = "info") {
-    this.defaultEndpoint = "https://kiloscribe.com/api/inscription-cdn";
-    this.logger = Logger.getInstance({
-      level: logLevel,
-      module: "HRLResolver"
-    });
+import { readString, readSubjectAdditional, isJsonObject } from "./standards-sdk.es201.js";
+import "./standards-sdk.es184.js";
+import "./standards-sdk.es198.js";
+import "./standards-sdk.es199.js";
+import "./standards-sdk.es200.js";
+import "./standards-sdk.es183.js";
+import { resolveSubjectEndpoint } from "./standards-sdk.es127.js";
+import { requestJson, requestText, Hcs25CollectorHttpError, isTimeoutError } from "./standards-sdk.es122.js";
+const GITHUB_API_BASE = "https://api.github.com";
+const NPM_API_BASE = "https://api.npmjs.org";
+const NPM_REGISTRY_BASE = "https://registry.npmjs.org";
+const PYPISTATS_API_BASE = "https://pypistats.org/api";
+const PYPI_API_BASE = "https://pypi.org/pypi";
+const RAW_GITHUB_BASE = "https://raw.githubusercontent.com";
+const GITHUB_REPO_PATTERN = /github\.com[:/]+([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)/;
+function parseGithubRepo(value) {
+  if (!value) {
+    return null;
   }
-  /**
-   * Determines if a MIME type represents binary content
-   */
-  isBinaryContentType(mimeType) {
-    const binaryTypes = [
-      "image/",
-      "audio/",
-      "video/",
-      "application/octet-stream",
-      "application/pdf",
-      "application/zip",
-      "application/gzip",
-      "application/x-binary",
-      "application/vnd.ms-",
-      "application/x-msdownload",
-      "application/x-shockwave-flash",
-      "font/",
-      "application/wasm"
-    ];
-    return binaryTypes.some((prefix) => mimeType.startsWith(prefix));
+  const direct = value.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/);
+  if (direct) {
+    return `${direct[1]}/${direct[2]}`;
   }
-  /**
-   * Parses an HRL string into its components
-   */
-  parseHRL(hrl) {
-    if (!hrl) {
-      return null;
-    }
-    const hrlPattern = /^hcs:\/\/(\d+)\/([0-9]+\.[0-9]+\.[0-9]+)$/;
-    const match = hrl.match(hrlPattern);
-    if (!match) {
-      return null;
+  const match = value.match(GITHUB_REPO_PATTERN);
+  if (!match) {
+    return null;
+  }
+  return `${match[1]}/${match[2].replace(/\.git$/, "")}`;
+}
+function resolveGithubRepo(subject) {
+  const additional = readSubjectAdditional(subject);
+  const metadata = subject.metadata ?? {};
+  const mcp = isJsonObject(metadata.mcp) ? metadata.mcp : void 0;
+  for (const value of [
+    readString(additional, "githubRepo"),
+    readString(additional, "repository"),
+    readString(metadata, "repository"),
+    readString(mcp, "repository"),
+    readString(metadata, "repoUrl"),
+    readString(additional, "repoUrl"),
+    readString(metadata, "homepage"),
+    readString(additional, "homepage"),
+    resolveSubjectEndpoint(subject)
+  ]) {
+    const repo = parseGithubRepo(value);
+    if (repo) {
+      return repo;
     }
-    return {
-      standard: match[1],
-      topicId: match[2]
-    };
   }
-  /**
-   * Validates if a string is a valid HRL
-   */
-  isValidHRL(hrl) {
-    if (!hrl || typeof hrl !== "string") {
-      return false;
+  return null;
+}
+function resolvePackage(subject) {
+  const additional = readSubjectAdditional(subject);
+  const registry = readString(additional, "packageRegistry");
+  const name = readString(additional, "packageName");
+  if (name && (registry === "npm" || registry === "pypi")) {
+    return { registry, name };
+  }
+  if (name) {
+    return { registry: "npm", name };
+  }
+  return null;
+}
+function statusFromError(error) {
+  if (error instanceof Hcs25CollectorHttpError && error.status === 404) {
+    return "missing";
+  }
+  return isTimeoutError(error) ? "timeout" : "error";
+}
+const parseLikelyPackageName = (value) => {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  return /^[a-zA-Z0-9._~@/-]{1,214}$/.test(trimmed) ? trimmed : null;
+};
+const parseNpmPackageName = (body) => {
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed.name === "string" ? parsed.name : null;
+  } catch {
+    return null;
+  }
+};
+const parsePyProjectName = (body) => {
+  const match = body.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+  return match?.[1] ?? null;
+};
+const parseSetupCfgName = (body) => {
+  const match = body.match(/^\s*name\s*=\s*(\S+)\s*$/m);
+  return match?.[1] ?? null;
+};
+async function inferPackageIdentity(repo, context) {
+  const base = `${RAW_GITHUB_BASE}/${repo.split("/").map(encodeURIComponent).join("/")}`;
+  let npmName = null;
+  let pypiName = null;
+  for (const branch of ["main", "master"]) {
+    if (!npmName) {
+      try {
+        const body = await requestText(`${base}/${branch}/package.json`, {
+          fetch: context.fetch,
+          timeoutMs: context.timeoutMs,
+          signal: context.signal
+        });
+        npmName = parseLikelyPackageName(parseNpmPackageName(body));
+      } catch {
+      }
     }
-    const parsed = this.parseHRL(hrl);
-    if (!parsed) {
-      return false;
+    if (!pypiName) {
+      try {
+        const body = await requestText(`${base}/${branch}/pyproject.toml`, {
+          fetch: context.fetch,
+          timeoutMs: context.timeoutMs,
+          signal: context.signal
+        });
+        pypiName = parseLikelyPackageName(parsePyProjectName(body));
+      } catch {
+        try {
+          const body = await requestText(`${base}/${branch}/setup.cfg`, {
+            fetch: context.fetch,
+            timeoutMs: context.timeoutMs,
+            signal: context.signal
+          });
+          pypiName = parseLikelyPackageName(parseSetupCfgName(body));
+        } catch {
+        }
+      }
     }
-    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
-    if (!topicIdPattern.test(parsed.topicId)) {
-      return false;
+    if (npmName || pypiName) {
+      break;
     }
-    return true;
   }
-  /**
-   * Validates if a string is a valid topic ID
-   */
-  isValidTopicId(topicId) {
-    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
-    return topicIdPattern.test(topicId);
+  if (npmName && !pypiName) {
+    return { registry: "npm", name: npmName };
   }
-  /**
-   * Resolves content from either an HRL or a topic ID
-   * If a topic ID is provided, it queries the topic memo to determine the HCS standard
-   */
-  async resolve(hrlOrTopicId, options) {
-    if (this.isValidHRL(hrlOrTopicId)) {
-      return this.resolveHRL(hrlOrTopicId, options);
-    }
-    if (!this.isValidTopicId(hrlOrTopicId)) {
-      throw new Error(`Invalid HRL or topic ID format: ${hrlOrTopicId}`);
-    }
-    try {
-      const mirrorNode = new HederaMirrorNode(options.network, this.logger);
-      const topicInfo = await mirrorNode.getTopicInfo(hrlOrTopicId);
-      const memo = topicInfo?.memo || "";
-      let standard = "1";
-      if (memo) {
-        const hcsMatch = memo.match(/^hcs-(\d+)/);
-        if (hcsMatch && hcsMatch[1]) {
-          standard = hcsMatch[1];
+  if (pypiName && !npmName) {
+    return { registry: "pypi", name: pypiName };
+  }
+  return null;
+}
+async function inferRepositoryFromPackage(pkg, context) {
+  const candidates = [];
+  try {
+    if (pkg.registry === "pypi") {
+      const payload = await requestJson(`${PYPI_API_BASE}/${encodeURIComponent(pkg.name)}/json`, {
+        fetch: context.fetch,
+        timeoutMs: context.timeoutMs,
+        signal: context.signal
+      });
+      const home = payload.info?.home_page;
+      if (typeof home === "string") {
+        candidates.push(home);
+      }
+      const urls = payload.info?.project_urls;
+      if (urls && typeof urls === "object" && !Array.isArray(urls)) {
+        for (const value of Object.values(urls)) {
+          if (typeof value === "string") {
+            candidates.push(value);
+          }
         }
       }
-      const hrl = `hcs://${standard}/${hrlOrTopicId}`;
-      return this.resolveHRL(hrl, options);
-    } catch (error) {
-      this.logger.error(
-        `Failed to get topic info for ${hrlOrTopicId}: ${error.message}`
-      );
-      const hrl = `hcs://1/${hrlOrTopicId}`;
-      return this.resolveHRL(hrl, options);
+    } else {
+      const payload = await requestJson(`${NPM_REGISTRY_BASE}/${encodeURIComponent(pkg.name)}`, {
+        fetch: context.fetch,
+        timeoutMs: context.timeoutMs,
+        signal: context.signal
+      });
+      const repo = payload.repository && typeof payload.repository === "object" && !Array.isArray(payload.repository) ? payload.repository.url : payload.repository;
+      if (typeof repo === "string") {
+        candidates.push(repo);
+      }
+      if (typeof payload.homepage === "string") {
+        candidates.push(payload.homepage);
+      }
+      const bugs = payload.bugs && typeof payload.bugs === "object" && !Array.isArray(payload.bugs) ? payload.bugs.url : payload.bugs;
+      if (typeof bugs === "string") {
+        candidates.push(bugs);
+      }
     }
+  } catch {
+    return null;
   }
-  async getContentWithType(hrl, options) {
-    if (!this.isValidHRL(hrl)) {
-      return {
-        content: hrl,
-        contentType: "text/plain",
-        isBinary: false
-      };
-    }
-    try {
-      const result = await this.resolveHRL(hrl, options);
-      return {
-        content: result.content,
-        contentType: result.contentType,
-        isBinary: result.isBinary
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Error resolving HRL for content and type: ${error.message}`;
-      this.logger.error(logMessage);
-      throw new Error(logMessage);
+  for (const candidate of candidates) {
+    const repo = parseGithubRepo(candidate);
+    if (repo) {
+      return repo;
     }
   }
-  /**
-   * Resolves HRL content with proper content type detection
-   */
-  async resolveHRL(hrl, options) {
-    const parsed = this.parseHRL(hrl);
-    if (!parsed) {
-      throw new Error(`Invalid HRL format: ${hrl}`);
+  return null;
+}
+async function fetchGithubStarsViaHtml(repo, context) {
+  const url = `https://github.com/${repo.split("/").map(encodeURIComponent).join("/")}`;
+  const body = await requestText(url, {
+    fetch: context.fetch,
+    timeoutMs: context.timeoutMs,
+    signal: context.signal,
+    headers: { accept: "text/html" }
+  });
+  const match = body.match(
+    /id="repo-stars-counter-star"[^>]*aria-label="(?<count>[0-9,]+)\s+users?\s+starred/i
+  ) ?? body.match(/id="repo-stars-counter-star"[^>]*title="(?<count>[0-9,]+)"/i);
+  const raw = match?.groups?.count;
+  if (!raw) {
+    return null;
+  }
+  const parsed = Number(raw.replace(/,/g, ""));
+  return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : null;
+}
+function createOssPopularitySignalAdapter(options = {}) {
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    let repo = resolveGithubRepo(subject);
+    let pkg = resolvePackage(subject);
+    if (!repo && pkg && options.inferRepository !== false) {
+      repo = await inferRepositoryFromPackage(pkg, context).catch(
+        () => null
+      );
     }
-    const { standard, topicId } = parsed;
-    this.logger.debug(
-      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`
-    );
-    try {
-      const cdnEndpoint = options.cdnEndpoint || this.defaultEndpoint;
-      const cdnUrl = `${cdnEndpoint}/${topicId}?network=${options.network}`;
-      this.logger.debug(`Fetching content from CDN: ${cdnUrl}`);
-      const headResponse = await axios.head(cdnUrl);
-      const contentType = headResponse.headers["content-type"] || "";
-      const isBinary = this.isBinaryContentType(contentType);
-      if (isBinary || options.returnRaw) {
-        const response2 = await axios.get(cdnUrl, {
-          responseType: "arraybuffer"
-        });
-        return {
-          content: response2.data,
-          contentType,
-          topicId,
-          isBinary: true
+    if (!pkg && repo && options.inferPackageIdentity !== false) {
+      pkg = await inferPackageIdentity(repo, context).catch(() => null);
+    }
+    const results = [];
+    const additional = {};
+    if (repo) {
+      additional.githubRepo = repo;
+      additional.packageRepositoryUpdatedAt = now;
+      try {
+        const headers = {
+          accept: "application/vnd.github+json"
         };
-      }
-      if (contentType === "application/json") {
-        const response2 = await axios.get(cdnUrl, {
-          responseType: "json"
-        });
-        if (!response2.data) {
-          throw new Error(`Failed to fetch content from topic: ${topicId}`);
+        if (options.githubToken) {
+          headers.authorization = `Bearer ${options.githubToken}`;
         }
-        return {
-          content: response2.data,
-          contentType,
-          topicId,
-          isBinary: false
-        };
-      }
-      const response = await axios.get(cdnUrl);
-      if (!response.data) {
-        throw new Error(`Failed to fetch content from topic: ${topicId}`);
+        let stars = null;
+        try {
+          const data = await requestJson(
+            `${options.githubApiBase ?? GITHUB_API_BASE}/repos/${repo}`,
+            {
+              fetch: context.fetch,
+              headers,
+              timeoutMs: context.timeoutMs,
+              signal: context.signal
+            }
+          );
+          stars = typeof data.stargazers_count === "number" ? Math.max(0, Math.floor(data.stargazers_count)) : null;
+        } catch (error) {
+          if (options.githubHtmlFallback === false) {
+            throw error;
+          }
+        }
+        if (stars === null && options.githubHtmlFallback !== false) {
+          stars = await fetchGithubStarsViaHtml(repo, context).catch(
+            () => null
+          );
+        }
+        additional.githubStars = stars;
+        additional.githubStarsUpdatedAt = now;
+        results.push({
+          signalId: "oss.github_stars",
+          status: stars === null ? "missing" : "ok",
+          value: stars,
+          provenance: {
+            source: "github",
+            sourceUrl: `${options.githubApiBase ?? GITHUB_API_BASE}/repos/${repo}`,
+            subjectId: repo,
+            fetchedAt: now
+          }
+        });
+      } catch (error) {
+        results.push({
+          signalId: "oss.github_stars",
+          status: statusFromError(error),
+          provenance: {
+            source: "github",
+            subjectId: repo,
+            fetchedAt: now
+          }
+        });
       }
-      let content;
-      if (typeof response.data === "object") {
-        content = response.data.content || response.data.text || JSON.stringify(response.data);
-      } else {
-        content = response.data;
+    }
+    if (pkg) {
+      additional.packageRegistry = pkg.registry;
+      additional.packageName = pkg.name;
+      additional.packageIdentityUpdatedAt = now;
+      const signalId = pkg.registry === "npm" ? "oss.npm_downloads" : "oss.pypi_downloads";
+      try {
+        if (pkg.registry === "npm") {
+          const data = await requestJson(
+            `${options.npmApiBase ?? NPM_API_BASE}/downloads/point/last-month/${encodeURIComponent(pkg.name)}`,
+            {
+              fetch: context.fetch,
+              timeoutMs: context.timeoutMs,
+              signal: context.signal
+            }
+          );
+          const downloads = typeof data.downloads === "number" ? Math.max(0, Math.floor(data.downloads)) : null;
+          additional.npmDownloads30d = downloads;
+          additional.npmDownloadsUpdatedAt = now;
+          if (downloads !== null) {
+            additional.packageDownloadCount = downloads;
+          }
+          results.push({
+            signalId,
+            status: downloads === null ? "missing" : "ok",
+            value: downloads,
+            provenance: {
+              source: "npm",
+              subjectId: pkg.name,
+              fetchedAt: now
+            }
+          });
+        } else {
+          const data = await requestJson(
+            `${options.pypiApiBase ?? PYPISTATS_API_BASE}/packages/${encodeURIComponent(pkg.name)}/recent`,
+            {
+              fetch: context.fetch,
+              timeoutMs: context.timeoutMs,
+              signal: context.signal
+            }
+          );
+          const downloads = typeof data.data?.last_month === "number" ? Math.max(0, Math.floor(data.data.last_month)) : null;
+          additional.pypiDownloads30d = downloads;
+          additional.pypiDownloadsUpdatedAt = now;
+          if (downloads !== null) {
+            additional.packageDownloadCount = downloads;
+          }
+          results.push({
+            signalId,
+            status: downloads === null ? "missing" : "ok",
+            value: downloads,
+            provenance: {
+              source: "pypi",
+              subjectId: pkg.name,
+              fetchedAt: now
+            }
+          });
+        }
+      } catch (error) {
+        results.push({
+          signalId,
+          status: statusFromError(error),
+          provenance: {
+            source: pkg.registry,
+            subjectId: pkg.name,
+            fetchedAt: now
+          }
+        });
       }
-      return {
-        content,
-        contentType,
-        topicId,
-        isBinary: false
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Error resolving HRL reference: ${error.message}`;
-      this.logger.error(logMessage);
-      throw new Error(logMessage);
     }
-  }
+    if (results.length === 0) {
+      return [
+        {
+          signalId: "oss.github_stars",
+          status: "missing"
+        }
+      ];
+    }
+    const rootValues = {};
+    if (repo && !readString(subject.metadata ?? {}, "repository")) {
+      rootValues.repository = `https://github.com/${repo}`;
+    }
+    results.push({
+      signalId: "oss.popularity",
+      status: "ok",
+      fields: [
+        { scope: "additional", values: additional },
+        ...Object.keys(rootValues).length > 0 ? [{ scope: "root", values: rootValues }] : []
+      ],
+      provenance: {
+        source: "oss-popularity",
+        subjectId: subject.id,
+        fetchedAt: now
+      }
+    });
+    return results;
+  };
+  return {
+    id: "oss-popularity",
+    produces: [
+      "oss.github_stars",
+      "oss.npm_downloads",
+      "oss.pypi_downloads",
+      "oss.popularity"
+    ],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries,
+    excludeRegistries: options.excludeRegistries,
+    appliesTo: options.appliesTo,
+    collect
+  };
 }
 export {
-  HRLResolver
+  createOssPopularitySignalAdapter,
+  parseGithubRepo
 };
 //# sourceMappingURL=standards-sdk.es132.js.map