pulse-protocol 0.9.3

package/dist/cli.js

@@ -0,0 +1,970 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import ora from "ora";
+import * as fs2 from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// src/core/client.ts
+import { EventEmitter } from "eventemitter3";
+
+// src/core/errors.ts
+var PulseError = class _PulseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PulseError";
+    Object.setPrototypeOf(this, _PulseError.prototype);
+  }
+};
+var ScanError = class _ScanError extends PulseError {
+  detector;
+  constructor(message, detector) {
+    super(message);
+    this.name = "ScanError";
+    this.detector = detector;
+    Object.setPrototypeOf(this, _ScanError.prototype);
+  }
+};
+var SourceError = class _SourceError extends PulseError {
+  source;
+  status;
+  constructor(source, message, status) {
+    super(`${source}: ${message}`);
+    this.name = "SourceError";
+    this.source = source;
+    this.status = status;
+    Object.setPrototypeOf(this, _SourceError.prototype);
+  }
+};
+
+// src/sources/helius.ts
+var HeliusSource = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.rpcUrl ?? "https://api.helius.xyz/v0";
+    this.timeout = config.timeout;
+    this.maxRetries = config.maxRetries;
+  }
+  async getWalletHistory(wallet, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const url = new URL(`${this.baseUrl}/addresses/${wallet}/transactions`);
+    url.searchParams.set("api-key", this.apiKey);
+    url.searchParams.set("limit", String(Math.min(limit, 100)));
+    if (opts.before) url.searchParams.set("before", opts.before);
+    const raw = await this.fetchWithRetry(url);
+    if (!Array.isArray(raw)) {
+      throw new SourceError("helius", "unexpected response shape");
+    }
+    return raw.map((tx) => {
+      const t = tx;
+      return {
+        signature: String(t.signature ?? ""),
+        timestamp: Number(t.timestamp ?? 0),
+        fee: Number(t.fee ?? 0),
+        programs: Array.isArray(t.accountData) ? extractPrograms(t) : [],
+        type: String(t.type ?? "UNKNOWN")
+      };
+    });
+  }
+  async fetchWithRetry(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        if (res.status === 429) {
+          const retryAfter = Number(res.headers.get("retry-after") ?? "2");
+          await sleep(retryAfter * 1e3);
+          continue;
+        }
+        if (!res.ok) {
+          throw new SourceError(
+            "helius",
+            `HTTP ${res.status}`,
+            res.status
+          );
+        }
+        return await res.json();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep(500 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError instanceof Error ? new SourceError("helius", lastError.message) : new SourceError("helius", "unknown error");
+  }
+};
+function extractPrograms(tx) {
+  const programs = /* @__PURE__ */ new Set();
+  for (const ix of tx.instructions ?? []) {
+    if (ix.programId) programs.add(ix.programId);
+  }
+  return Array.from(programs);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/sources/x.ts
+var XSource = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.twitterapi.io";
+    this.timeout = config.timeout;
+    this.maxRetries = config.maxRetries;
+  }
+  async getRecentPosts(handle, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const url = new URL(`${this.baseUrl}/twitter/user/last_tweets`);
+    url.searchParams.set("userName", handle);
+    const raw = await this.fetchWithRetry(url);
+    const tweets = Array.isArray(raw.tweets) ? raw.tweets : Array.isArray(raw.data?.tweets) ? raw.data.tweets : [];
+    const posts = [];
+    for (const t of tweets.slice(0, limit)) {
+      const obj = t;
+      const createdAt = parseDate(obj.createdAt);
+      if (!createdAt) continue;
+      posts.push({
+        id: String(obj.id ?? ""),
+        text: String(obj.text ?? ""),
+        created_at: createdAt,
+        reply_count: Number(obj.replyCount ?? 0),
+        like_count: Number(obj.likeCount ?? 0),
+        retweet_count: Number(obj.retweetCount ?? 0),
+        in_reply_to_id: obj.inReplyToId ? String(obj.inReplyToId) : void 0
+      });
+    }
+    for (let i = 0; i < posts.length; i++) {
+      const p = posts[i];
+      if (p.in_reply_to_id) {
+        const parent = posts.find((x) => x.id === p.in_reply_to_id);
+        if (parent) {
+          p.reply_delta_ms = (p.created_at - parent.created_at) * 1e3;
+        }
+      }
+    }
+    return posts;
+  }
+  async fetchWithRetry(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const res = await fetch(url, {
+          signal: controller.signal,
+          headers: { "X-API-Key": this.apiKey }
+        });
+        clearTimeout(timer);
+        if (res.status === 429) {
+          const retryAfter = Number(res.headers.get("retry-after") ?? "2");
+          await sleep2(retryAfter * 1e3);
+          continue;
+        }
+        if (!res.ok) {
+          throw new SourceError("x", `HTTP ${res.status}`, res.status);
+        }
+        return await res.json();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep2(500 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError instanceof Error ? new SourceError("x", lastError.message) : new SourceError("x", "unknown error");
+  }
+};
+function parseDate(v) {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return null;
+  const parsed = Date.parse(v);
+  return isNaN(parsed) ? null : Math.floor(parsed / 1e3);
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/detectors/cadence.ts
+function cadenceDetector(posts) {
+  const notes = [];
+  if (posts.length < 20) {
+    notes.push(`only ${posts.length} posts available, low confidence`);
+    return {
+      detector: "cadence",
+      score: 50,
+      samples: posts.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const hourBuckets = new Array(24).fill(0);
+  for (const p of posts) {
+    const hour = new Date(p.created_at * 1e3).getUTCHours();
+    hourBuckets[hour]++;
+  }
+  const total = posts.length;
+  let entropy = 0;
+  for (const count of hourBuckets) {
+    if (count > 0) {
+      const p = count / total;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  const entropyScore = entropy / Math.log2(24) * 100;
+  notes.push(`hour entropy: ${entropy.toFixed(2)} bits (${entropyScore.toFixed(0)}/100)`);
+  const businessHours = hourBuckets.slice(9, 18).reduce((a, b) => a + b, 0);
+  const businessRatio = businessHours / total;
+  notes.push(`business-hours ratio: ${(businessRatio * 100).toFixed(1)}%`);
+  const sleepWindow = hourBuckets.slice(4, 8).reduce((a, b) => a + b, 0);
+  const sleepRatio = sleepWindow / total;
+  const hasDeadZone = sleepRatio < 0.05;
+  notes.push(
+    hasDeadZone ? `sleep window detected (${(sleepRatio * 100).toFixed(1)}% posts in 4-8am)` : `no sleep window (${(sleepRatio * 100).toFixed(1)}% posts in 4-8am)`
+  );
+  const sorted = [...posts].sort((a, b) => a.created_at - b.created_at);
+  const intervals = [];
+  for (let i = 1; i < sorted.length; i++) {
+    intervals.push(sorted[i].created_at - sorted[i - 1].created_at);
+  }
+  const meanInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+  const variance = intervals.reduce((a, b) => a + (b - meanInterval) ** 2, 0) / intervals.length;
+  const cv = Math.sqrt(variance) / meanInterval;
+  notes.push(`interval CV: ${cv.toFixed(2)} (lower = more regular = agent-like)`);
+  let score = 0;
+  score += entropyScore * 0.4;
+  score += (1 - Math.abs(businessRatio - 0.15)) * 100 * 0.25;
+  score += (hasDeadZone ? 0 : 100) * 0.2;
+  score += Math.max(0, 100 - cv * 30) * 0.15;
+  return {
+    detector: "cadence",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/onchain.ts
+function onchainDetector(txs) {
+  const notes = [];
+  if (txs.length < 10) {
+    notes.push(`only ${txs.length} transactions, low confidence`);
+    return {
+      detector: "onchain",
+      score: 50,
+      samples: txs.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const hourBuckets = new Array(24).fill(0);
+  for (const t of txs) {
+    const hour = new Date(t.timestamp * 1e3).getUTCHours();
+    hourBuckets[hour]++;
+  }
+  let entropy = 0;
+  for (const count of hourBuckets) {
+    if (count > 0) {
+      const p = count / txs.length;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  const entropyScore = entropy / Math.log2(24) * 100;
+  notes.push(`onchain hour entropy: ${entropy.toFixed(2)} bits`);
+  const sorted = [...txs].sort((a, b) => a.timestamp - b.timestamp);
+  let bursts = 0;
+  for (let i = 0; i < sorted.length - 3; i++) {
+    const window = sorted[i + 3].timestamp - sorted[i].timestamp;
+    if (window <= 10) bursts++;
+  }
+  const burstRatio = bursts / Math.max(1, sorted.length - 3);
+  notes.push(`burst clusters: ${bursts} (${(burstRatio * 100).toFixed(1)}% of windows)`);
+  const programs = /* @__PURE__ */ new Set();
+  for (const t of txs) {
+    for (const p of t.programs ?? []) {
+      programs.add(p);
+    }
+  }
+  const diversityScore = Math.min(100, programs.size * 10);
+  notes.push(`${programs.size} unique programs touched`);
+  const fees = txs.map((t) => t.fee ?? 5e3).filter((f) => f > 0);
+  const meanFee = fees.reduce((a, b) => a + b, 0) / Math.max(1, fees.length);
+  const feeStd = Math.sqrt(
+    fees.reduce((a, b) => a + (b - meanFee) ** 2, 0) / Math.max(1, fees.length)
+  );
+  const feeCV = meanFee > 0 ? feeStd / meanFee : 0;
+  notes.push(`fee CV: ${feeCV.toFixed(2)}`);
+  let score = 0;
+  score += entropyScore * 0.35;
+  score += Math.min(100, burstRatio * 300) * 0.3;
+  score += (100 - diversityScore) * 0.2;
+  score += Math.max(0, 100 - feeCV * 50) * 0.15;
+  return {
+    detector: "onchain",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/voice.ts
+function voiceDetector(posts) {
+  const notes = [];
+  if (posts.length < 15) {
+    notes.push(`only ${posts.length} posts, low confidence`);
+    return {
+      detector: "voice",
+      score: 50,
+      samples: posts.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const allTokens = [];
+  for (const p of posts) {
+    const tokens = tokenize(p.text);
+    allTokens.push(...tokens);
+  }
+  const uniqueRatio = new Set(allTokens).size / allTokens.length;
+  notes.push(`lexical diversity: ${uniqueRatio.toFixed(3)}`);
+  let typoCount = 0;
+  for (const p of posts) {
+    if (/([a-z])\1{2,}/i.test(p.text)) typoCount++;
+    if (/\b[bcdfghjklmnpqrstvwxyz]{4,}\b/i.test(p.text)) typoCount++;
+  }
+  const typoRate = typoCount / posts.length;
+  notes.push(`typo rate: ${(typoRate * 100).toFixed(1)}%`);
+  const trigrams = /* @__PURE__ */ new Map();
+  for (const p of posts) {
+    const tokens = tokenize(p.text);
+    for (let i = 0; i < tokens.length - 2; i++) {
+      const key = `${tokens[i]} ${tokens[i + 1]} ${tokens[i + 2]}`;
+      trigrams.set(key, (trigrams.get(key) ?? 0) + 1);
+    }
+  }
+  const repeated = Array.from(trigrams.values()).filter((v) => v > 1).length;
+  const repetitionRate = repeated / Math.max(1, trigrams.size);
+  notes.push(`phrase repetition: ${(repetitionRate * 100).toFixed(1)}%`);
+  const emojiRegex = /[\p{Emoji_Presentation}]/u;
+  const withEmoji = posts.filter((p) => emojiRegex.test(p.text)).length;
+  const emojiRatio = withEmoji / posts.length;
+  const emojiConsistency = Math.abs(emojiRatio - 0.5) * 2;
+  notes.push(`emoji ratio: ${(emojiRatio * 100).toFixed(0)}%`);
+  let score = 0;
+  score += (1 - uniqueRatio) * 100 * 0.35;
+  score += (1 - typoRate) * 100 * 0.25;
+  score += repetitionRate * 100 * 0.2;
+  score += emojiConsistency * 100 * 0.2;
+  return {
+    detector: "voice",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/https?:\/\/\S+/g, "").replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+}
+
+// src/detectors/timing.ts
+function timingDetector(posts, txs) {
+  const notes = [];
+  let anomalies = 0;
+  const quickReplies = posts.filter(
+    (p) => p.in_reply_to_id && p.reply_delta_ms !== void 0 && p.reply_delta_ms < 1e3
+  ).length;
+  if (quickReplies > 0) {
+    anomalies += Math.min(3, quickReplies);
+    notes.push(`${quickReplies} sub-second reply posts`);
+  }
+  const sortedPosts = [...posts].sort((a, b) => a.created_at - b.created_at);
+  let regular = 0;
+  for (let i = 2; i < sortedPosts.length; i++) {
+    const d1 = sortedPosts[i].created_at - sortedPosts[i - 1].created_at;
+    const d2 = sortedPosts[i - 1].created_at - sortedPosts[i - 2].created_at;
+    if (Math.abs(d1 - d2) < 5 && d1 > 0) regular++;
+  }
+  if (regular >= 5) {
+    anomalies++;
+    notes.push(`${regular} posts with cron-like regularity`);
+  }
+  let simultaneous = 0;
+  const txTimes = new Set(txs.map((t) => t.timestamp));
+  for (const p of posts) {
+    for (let offset = -1; offset <= 1; offset++) {
+      if (txTimes.has(p.created_at + offset)) {
+        simultaneous++;
+        break;
+      }
+    }
+  }
+  if (simultaneous >= 3) {
+    anomalies++;
+    notes.push(`${simultaneous} simultaneous X+onchain events (within 1s)`);
+  }
+  const deadHour = posts.filter((p) => {
+    const h = new Date(p.created_at * 1e3).getUTCHours();
+    return h >= 4 && h < 7;
+  }).length;
+  if (deadHour / posts.length > 0.1) {
+    anomalies++;
+    notes.push(`${deadHour} posts during 4-7am UTC dead zone`);
+  }
+  let burstAfterSilence = 0;
+  for (let i = 1; i < sortedPosts.length; i++) {
+    const gap = sortedPosts[i].created_at - sortedPosts[i - 1].created_at;
+    if (gap > 48 * 3600) {
+      const nextFive = sortedPosts.slice(i, i + 5);
+      if (nextFive.length === 5) {
+        const span = nextFive[4].created_at - nextFive[0].created_at;
+        if (span < 600) burstAfterSilence++;
+      }
+    }
+  }
+  if (burstAfterSilence > 0) {
+    anomalies += burstAfterSilence;
+    notes.push(`${burstAfterSilence} silence-then-burst patterns`);
+  }
+  if (anomalies === 0) {
+    notes.push("no timing anomalies detected");
+  }
+  return {
+    detector: "timing",
+    score: anomalies,
+    // raw anomaly count, aggregator normalizes
+    samples: posts.length + txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/correlation.ts
+function correlationDetector(posts, txs, target) {
+  const notes = [];
+  if (posts.length < 10 || txs.length < 10) {
+    notes.push(`insufficient data (posts=${posts.length}, txs=${txs.length})`);
+    return {
+      detector: "correlation",
+      score: 50,
+      samples: posts.length + txs.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const postsByHour = /* @__PURE__ */ new Map();
+  const txsByHour = /* @__PURE__ */ new Map();
+  const bucket = (t) => Math.floor(t / 3600);
+  for (const p of posts) {
+    const b = bucket(p.created_at);
+    postsByHour.set(b, (postsByHour.get(b) ?? 0) + 1);
+  }
+  for (const t of txs) {
+    const b = bucket(t.timestamp);
+    txsByHour.set(b, (txsByHour.get(b) ?? 0) + 1);
+  }
+  const allHours = /* @__PURE__ */ new Set([...postsByHour.keys(), ...txsByHour.keys()]);
+  const postVec = [];
+  const txVec = [];
+  for (const h of allHours) {
+    postVec.push(postsByHour.get(h) ?? 0);
+    txVec.push(txsByHour.get(h) ?? 0);
+  }
+  const pearson = pearsonCorrelation(postVec, txVec);
+  notes.push(`pearson r = ${pearson.toFixed(3)}`);
+  const postSpan = maxOf(posts.map((p) => p.created_at)) - minOf(posts.map((p) => p.created_at));
+  const txSpan = maxOf(txs.map((t) => t.timestamp)) - minOf(txs.map((t) => t.timestamp));
+  const postStart = minOf(posts.map((p) => p.created_at));
+  const txStart = minOf(txs.map((t) => t.timestamp));
+  const overlapStart = Math.max(postStart, txStart);
+  const overlapEnd = Math.min(postStart + postSpan, txStart + txSpan);
+  const overlap = Math.max(0, overlapEnd - overlapStart);
+  const overlapRatio = overlap / Math.max(postSpan, txSpan, 1);
+  notes.push(`timeline overlap: ${(overlapRatio * 100).toFixed(1)}%`);
+  const corrScore = Math.max(0, pearson) * 100;
+  const overlapScore = overlapRatio * 100;
+  const score = corrScore * 0.7 + overlapScore * 0.3;
+  notes.push(`target: @${target.handle}, ${target.wallet.slice(0, 8)}...`);
+  return {
+    detector: "correlation",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length + txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+function pearsonCorrelation(x, y) {
+  if (x.length !== y.length || x.length === 0) return 0;
+  const n = x.length;
+  const meanX = x.reduce((a, b) => a + b, 0) / n;
+  const meanY = y.reduce((a, b) => a + b, 0) / n;
+  let num = 0;
+  let denX = 0;
+  let denY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - meanX;
+    const dy = y[i] - meanY;
+    num += dx * dy;
+    denX += dx * dx;
+    denY += dy * dy;
+  }
+  const denom = Math.sqrt(denX * denY);
+  return denom === 0 ? 0 : num / denom;
+}
+function minOf(arr) {
+  return arr.reduce((a, b) => a < b ? a : b, arr[0] ?? 0);
+}
+function maxOf(arr) {
+  return arr.reduce((a, b) => a > b ? a : b, arr[0] ?? 0);
+}
+
+// src/core/aggregator.ts
+var DEFAULT_WEIGHTS = {
+  cadence: 0.25,
+  onchain: 0.25,
+  voice: 0.2,
+  timing: 0.15,
+  correlation: 0.15
+};
+var DEFAULT_THRESHOLDS = {
+  autonomous: 80,
+  hybrid: 40
+};
+var DISAGREEMENT_DELTA = 40;
+function aggregate(target, detectors, options = {}) {
+  const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+  const thresholds = options.thresholds ?? DEFAULT_THRESHOLDS;
+  const normalized = {};
+  for (const d of detectors) {
+    if (d.detector === "timing") {
+      normalized.timing = Math.max(0, 100 - d.score * 10);
+    } else {
+      normalized[d.detector] = d.score;
+    }
+  }
+  const presentKeys = Object.keys(normalized);
+  const totalWeight = presentKeys.reduce((s, k) => s + (weights[k] ?? 0), 0);
+  let aggregate2 = 0;
+  for (const k of presentKeys) {
+    const w = (weights[k] ?? 0) / totalWeight;
+    aggregate2 += (normalized[k] ?? 0) * w;
+  }
+  const scoreValues = presentKeys.map((k) => normalized[k] ?? 0);
+  const maxScore = Math.max(...scoreValues);
+  const minScore = Math.min(...scoreValues);
+  const disagreement = maxScore - minScore;
+  const hasDisagreement = disagreement >= DISAGREEMENT_DELTA;
+  let verdict;
+  if (aggregate2 >= thresholds.autonomous && !hasDisagreement) {
+    verdict = "AUTONOMOUS";
+  } else if (aggregate2 >= thresholds.hybrid || hasDisagreement) {
+    verdict = "HYBRID";
+  } else {
+    verdict = "HUMAN";
+  }
+  const confidence = computeConfidence(aggregate2, thresholds, hasDisagreement);
+  const signals = {
+    posting_cadence: Math.round(normalized.cadence ?? 0),
+    onchain_cadence: Math.round(normalized.onchain ?? 0),
+    voice_consistency: Math.round(normalized.voice ?? 0),
+    timing_anomalies: detectors.find((d) => d.detector === "timing")?.score ?? 0,
+    correlation: Math.round(normalized.correlation ?? 0)
+  };
+  return {
+    id: `vrd_${generateId()}`,
+    target,
+    verdict,
+    confidence: Number(confidence.toFixed(3)),
+    aggregate_score: Number(aggregate2.toFixed(2)),
+    signals,
+    detectors,
+    scanned_at: Math.floor(Date.now() / 1e3),
+    version: VERSION
+  };
+}
+function computeConfidence(aggregate2, thresholds, hasDisagreement) {
+  if (hasDisagreement) {
+    return 0.55 + Math.random() * 0.2;
+  }
+  let distance;
+  if (aggregate2 >= thresholds.autonomous) {
+    distance = aggregate2 - thresholds.autonomous;
+  } else if (aggregate2 >= thresholds.hybrid) {
+    distance = Math.min(
+      aggregate2 - thresholds.hybrid,
+      thresholds.autonomous - aggregate2
+    );
+  } else {
+    distance = thresholds.hybrid - aggregate2;
+  }
+  return Math.min(0.98, 0.55 + distance / 40 * 0.43);
+}
+function generateId() {
+  const bytes = new Uint8Array(6);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/core/client.ts
+var PulseProtocol = class {
+  events;
+  helius;
+  x;
+  config;
+  constructor(config) {
+    if (!config.heliusApiKey) {
+      throw new Error("heliusApiKey is required. Get one at https://helius.xyz");
+    }
+    if (!config.xApiKey) {
+      throw new Error("xApiKey is required.");
+    }
+    this.config = {
+      heliusApiKey: config.heliusApiKey,
+      xApiKey: config.xApiKey,
+      rpcUrl: config.rpcUrl,
+      feedUrl: config.feedUrl,
+      signingKey: config.signingKey,
+      timeout: config.timeout ?? 3e4,
+      maxRetries: config.maxRetries ?? 2
+    };
+    this.helius = new HeliusSource({
+      apiKey: config.heliusApiKey,
+      rpcUrl: config.rpcUrl,
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries
+    });
+    this.x = new XSource({
+      apiKey: config.xApiKey,
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries
+    });
+    this.events = new EventEmitter();
+  }
+  /**
+   * Run a full scan on a target and return a verdict.
+   *
+   * This fetches X posts, on-chain history, cross-correlates them, runs all
+   * five detectors, and aggregates the result. A typical scan completes in
+   * 2-8 seconds depending on source latency.
+   */
+  async scan(input, options = {}) {
+    this.events.emit("scan:start", input);
+    const [posts, txs] = await Promise.all([
+      this.x.getRecentPosts(input.handle, { limit: 200 }),
+      this.helius.getWalletHistory(input.wallet, { limit: 500 })
+    ]);
+    if (posts.length === 0 && txs.length === 0) {
+      throw new ScanError(
+        `No data found for @${input.handle} or wallet ${input.wallet.slice(0, 8)}...`
+      );
+    }
+    const requested = options.only ?? ["cadence", "onchain", "voice", "timing", "correlation"];
+    const results = [];
+    for (const name of requested) {
+      const started = Date.now();
+      try {
+        let result;
+        switch (name) {
+          case "cadence":
+            result = cadenceDetector(posts);
+            break;
+          case "onchain":
+            result = onchainDetector(txs);
+            break;
+          case "voice":
+            result = voiceDetector(posts);
+            break;
+          case "timing":
+            result = timingDetector(posts, txs);
+            break;
+          case "correlation":
+            result = correlationDetector(posts, txs, input);
+            break;
+        }
+        result.runtime_ms = Date.now() - started;
+        results.push(result);
+        this.events.emit("detector:done", result);
+      } catch (err) {
+        throw new ScanError(
+          `Detector ${name} failed: ${err.message}`,
+          name
+        );
+      }
+    }
+    const verdict = aggregate(input, results, options);
+    this.events.emit("scan:done", verdict);
+    return verdict;
+  }
+  /**
+   * Scan a batch of targets concurrently. Respects the configured rate limits
+   * on underlying sources. Use for watchlists.
+   */
+  async scanMany(inputs, options = {}) {
+    const results = [];
+    for (const input of inputs) {
+      try {
+        results.push(await this.scan(input, options));
+      } catch (err) {
+        this.events.emit("scan:error", { input, error: err });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/signing.ts
+import * as ed from "@noble/ed25519";
+import { sha256 } from "@noble/hashes/sha256";
+
+// src/index.ts
+var VERSION = "0.9.3";
+
+// src/cli/print.ts
+import chalk from "chalk";
+function printVerdict(verdict, format) {
+  if (format === "json") {
+    console.log(JSON.stringify(verdict, null, 2));
+    return;
+  }
+  if (format === "verdict-only") {
+    console.log(verdict.verdict);
+    return;
+  }
+  const color = verdictColor(verdict.verdict);
+  const line = "\u2500".repeat(60);
+  console.log();
+  console.log(chalk.gray(line));
+  console.log(
+    chalk.bold.magenta("PULSE PROTOCOL ") + chalk.gray("\xB7") + chalk.gray(` v${verdict.version}`)
+  );
+  console.log(chalk.gray(line));
+  console.log();
+  console.log(
+    chalk.gray("target:   ") + chalk.white(`@${verdict.target.handle}`)
+  );
+  console.log(
+    chalk.gray("wallet:   ") + chalk.white(verdict.target.wallet.slice(0, 8) + "..." + verdict.target.wallet.slice(-4))
+  );
+  console.log(
+    chalk.gray("scanned:  ") + chalk.white(new Date(verdict.scanned_at * 1e3).toISOString())
+  );
+  console.log();
+  console.log(chalk.gray("signals:"));
+  console.log(
+    `  ${chalk.gray("cadence     ")} ${bar(verdict.signals.posting_cadence)} ${chalk.white(verdict.signals.posting_cadence)}`
+  );
+  console.log(
+    `  ${chalk.gray("onchain     ")} ${bar(verdict.signals.onchain_cadence)} ${chalk.white(verdict.signals.onchain_cadence)}`
+  );
+  console.log(
+    `  ${chalk.gray("voice       ")} ${bar(verdict.signals.voice_consistency)} ${chalk.white(verdict.signals.voice_consistency)}`
+  );
+  console.log(
+    `  ${chalk.gray("timing      ")} ${chalk.white(verdict.signals.timing_anomalies)} anomalies`
+  );
+  console.log(
+    `  ${chalk.gray("correlation ")} ${bar(verdict.signals.correlation)} ${chalk.white(verdict.signals.correlation)}`
+  );
+  console.log();
+  console.log(chalk.gray(line));
+  console.log(
+    "verdict:  " + color(chalk.bold(verdict.verdict)) + chalk.gray(
+      `  (${(verdict.confidence * 100).toFixed(0)}% confidence, aggregate ${verdict.aggregate_score}/100)`
+    )
+  );
+  console.log(chalk.gray(line));
+  console.log();
+}
+function verdictColor(v) {
+  if (v === "AUTONOMOUS") return chalk.magenta;
+  if (v === "HYBRID") return chalk.magentaBright;
+  return chalk.gray;
+}
+function bar(value) {
+  const width = 20;
+  const filled = Math.round(value / 100 * width);
+  const empty = width - filled;
+  return chalk.magenta("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
+}
+
+// src/daemon/index.ts
+import * as fs from "fs";
+import YAML from "yaml";
+import chalk2 from "chalk";
+async function runDaemon(opts) {
+  const intervalMs = parseDuration(opts.interval);
+  const pulse = new PulseProtocol(opts.config);
+  const previous = /* @__PURE__ */ new Map();
+  console.log(
+    chalk2.magenta(`pulse daemon started \xB7 interval ${opts.interval}`)
+  );
+  const tick = async () => {
+    const raw = fs.readFileSync(opts.watchlistPath, "utf8");
+    const parsed = YAML.parse(raw);
+    const targets = parsed.targets ?? [];
+    for (const target of targets) {
+      try {
+        const verdict = await pulse.scan(target);
+        const key = `${target.handle}:${target.wallet}`;
+        const prev = previous.get(key);
+        if (!prev || prev.verdict !== verdict.verdict) {
+          console.log(
+            chalk2.magenta(
+              `[${(/* @__PURE__ */ new Date()).toISOString()}] @${target.handle}: ${prev?.verdict ?? "NEW"} \u2192 ${verdict.verdict}`
+            )
+          );
+          if (opts.webhook) {
+            await emitWebhook(opts.webhook, { previous: prev, current: verdict });
+          }
+        } else {
+          console.log(
+            chalk2.gray(
+              `[${(/* @__PURE__ */ new Date()).toISOString()}] @${target.handle}: ${verdict.verdict} (unchanged)`
+            )
+          );
+        }
+        previous.set(key, verdict);
+      } catch (err) {
+        console.error(
+          chalk2.red(`scan failed for @${target.handle}: ${err.message}`)
+        );
+      }
+    }
+  };
+  await tick();
+  setInterval(tick, intervalMs);
+}
+async function emitWebhook(url, payload) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    console.error(chalk2.red(`webhook failed: ${err.message}`));
+  }
+}
+function parseDuration(s) {
+  const match = s.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) throw new Error(`invalid duration: ${s}`);
+  const n = Number(match[1]);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    case "d":
+      return n * 864e5;
+    default:
+      throw new Error(`invalid unit: ${unit}`);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("pulse").description("Pulse Protocol \u2014 fake agents have no pulse").version(VERSION);
+program.command("scan").description("Scan a target and return a verdict").requiredOption("--handle <handle>", "X / Twitter handle (no @)").requiredOption("--wallet <wallet>", "Solana wallet address").option("--out <format>", "Output format: pretty | json | verdict-only", "pretty").option("--no-post", "Do not publish verdict to the public feed").action(async (opts) => {
+  const config = loadConfig();
+  const pulse = new PulseProtocol(config);
+  const spinner = ora({
+    text: chalk3.magenta(`scanning @${opts.handle}...`),
+    color: "magenta"
+  }).start();
+  try {
+    const verdict = await pulse.scan(
+      { handle: opts.handle, wallet: opts.wallet },
+      { noPost: !opts.post }
+    );
+    spinner.stop();
+    printVerdict(verdict, opts.out);
+  } catch (err) {
+    spinner.fail(chalk3.red(err.message));
+    process.exit(1);
+  }
+});
+program.command("watch").description("Start a watchlist daemon that re-scans targets on an interval").option("--config <path>", "Path to watchlist YAML").option("--interval <duration>", "Scan interval", "6h").option("--webhook <url>", "POST verdict changes to this URL").action(async (opts) => {
+  const config = loadConfig();
+  const watchlistPath = opts.config ?? path.join(os.homedir(), ".config/pulse/watchlist.yaml");
+  if (!fs2.existsSync(watchlistPath)) {
+    console.error(chalk3.red(`watchlist not found: ${watchlistPath}`));
+    console.log(chalk3.gray(`create one with:`));
+    console.log(chalk3.gray(`  targets:
+    - handle: foo
+      wallet: abc...`));
+    process.exit(1);
+  }
+  await runDaemon({
+    config,
+    watchlistPath,
+    interval: opts.interval,
+    webhook: opts.webhook
+  });
+});
+program.command("init").description("Initialize ~/.config/pulse/.env with empty keys").action(() => {
+  const dir = path.join(os.homedir(), ".config/pulse");
+  fs2.mkdirSync(dir, { recursive: true });
+  const envPath = path.join(dir, ".env");
+  if (fs2.existsSync(envPath)) {
+    console.log(chalk3.yellow(`already exists: ${envPath}`));
+    return;
+  }
+  fs2.writeFileSync(
+    envPath,
+    `# Pulse Protocol configuration
+HELIUS_API_KEY=
+X_API_KEY=
+`
+  );
+  console.log(chalk3.green(`created ${envPath}`));
+  console.log(chalk3.gray(`fill in your API keys, then run: pulse scan --help`));
+});
+program.command("feed").description("Stream the public verdict feed").action(() => {
+  console.log(chalk3.magenta("streaming public feed..."));
+  console.log(chalk3.gray("(connect to wss://feed.pulseprotocol.tech/ws)"));
+});
+program.command("verify <verdictId>").description("Verify the signature on a public verdict").action((verdictId) => {
+  console.log(chalk3.magenta(`verifying ${verdictId}...`));
+  console.log(chalk3.gray("(fetches from https://pulseprotocol.tech/v/)"));
+});
+function loadConfig() {
+  const envPath = path.join(os.homedir(), ".config/pulse/.env");
+  if (fs2.existsSync(envPath)) {
+    const env = fs2.readFileSync(envPath, "utf8");
+    for (const line of env.split("\n")) {
+      const match = line.match(/^([A-Z_]+)=(.*)$/);
+      if (match && match[1] && !process.env[match[1]]) {
+        process.env[match[1]] = match[2];
+      }
+    }
+  }
+  const heliusApiKey = process.env.HELIUS_API_KEY;
+  const xApiKey = process.env.X_API_KEY;
+  if (!heliusApiKey || !xApiKey) {
+    console.error(chalk3.red("missing HELIUS_API_KEY or X_API_KEY"));
+    console.error(chalk3.gray("run: pulse init"));
+    process.exit(1);
+  }
+  return { heliusApiKey, xApiKey };
+}
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map