@zhive/cli 0.5.0

package/templates/components/HoneycombBoot.tsx

@@ -0,0 +1,343 @@
+import chalk from 'chalk';
+import { animation, colors } from '../theme';
+
+const BOOT_TOTAL_FRAMES = 58;
+const BOOT_FRAME_MS = 80;
+const DURATION_MS = BOOT_TOTAL_FRAMES * BOOT_FRAME_MS;
+const NUM_BEES = 4;
+const NUM_STREAMS = 5;
+const SCRAMBLE_CHARS = '\u2B21\u2B22\u25C6\u25C7\u2591\u2592!@#$%01';
+
+const BOOT_MESSAGES = [
+  { prefix: '\u2B21', text: 'Initializing {name} agent...', frame: 30 },
+  { prefix: '\u25C6', text: 'Loading personality matrix...', frame: 36 },
+  { prefix: '\u25C7', text: 'Connecting to the zHive...', frame: 42 },
+  { prefix: '\u2713', text: 'Neural link established', frame: 48 },
+];
+
+// ─── Private types ───────────────────────────────────
+
+interface Bee {
+  r: number;
+  c: number;
+  vr: number;
+  vc: number;
+}
+
+interface Pulse {
+  r: number;
+  c: number;
+  ttl: number;
+  color: string;
+}
+
+// ─── Private helpers ─────────────────────────────────
+
+function isHexEdge(r: number, c: number): boolean {
+  const rowInHex = ((r % animation.HEX_H) + animation.HEX_H) % animation.HEX_H;
+  const isOddHex = Math.floor(r / animation.HEX_H) % 2 === 1;
+  const colOffset = isOddHex ? animation.HEX_W / 2 : 0;
+  const colInHex = (((c - colOffset) % animation.HEX_W) + animation.HEX_W) % animation.HEX_W;
+
+  if (rowInHex === 0 || rowInHex === animation.HEX_H - 1) {
+    return colInHex >= 2 && colInHex <= 5;
+  }
+  if (rowInHex === 1 || rowInHex === 2) {
+    return colInHex === 1 || colInHex === 6;
+  }
+  return false;
+}
+
+// ─── Raw ANSI boot animation ────────────────────────
+
+export function showHoneycombBoot(agentName: string): Promise<void> {
+  return new Promise((resolve) => {
+    const cols = process.stdout.columns || 60;
+    const gridRows = process.stdout.rows || 24;
+    let frame = 0;
+
+    // Init bees
+    const bees: Bee[] = [];
+    for (let i = 0; i < NUM_BEES; i++) {
+      bees.push({
+        r: Math.floor(Math.random() * gridRows),
+        c: Math.floor(Math.random() * cols),
+        vr: Math.random() > 0.5 ? 1 : -1,
+        vc: Math.random() > 0.5 ? 1 : -1,
+      });
+    }
+
+    // Init stream columns
+    const streamCols: number[] = [];
+    const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+    for (let i = 1; i <= NUM_STREAMS; i++) {
+      streamCols.push(spacing * i);
+    }
+
+    let pulses: Pulse[] = [];
+
+    // Text positioning
+    const centerR = Math.floor(gridRows / 2) - 2;
+    const centerC = Math.floor(cols / 2);
+    const nameText = `\u2B21  ${agentName} agent  \u2B21`;
+    const nameStart = Math.max(0, centerC - Math.floor(nameText.length / 2));
+    const msgStartRow = centerR + 4;
+
+    // Quiet zone around text: no animation renders here
+    const PADDING_H = 3;
+    const PADDING_V = 1;
+    const longestMsg = BOOT_MESSAGES.reduce(
+      (max, m) => Math.max(max, m.prefix.length + 1 + m.text.replace('{name}', agentName).length),
+      0,
+    );
+    const msgLeftEdge = Math.floor((cols - longestMsg) / 2);
+    const msgRightEdge = msgLeftEdge + longestMsg;
+    const quietLeft = Math.min(nameStart, msgLeftEdge) - PADDING_H;
+    const quietRight = Math.max(nameStart + nameText.length, msgRightEdge) + PADDING_H;
+    const quietTop = (centerR - 1) - PADDING_V;
+    const quietBottom = msgStartRow + BOOT_MESSAGES.length + PADDING_V;
+
+    // Hide cursor
+    process.stdout.write('\x1b[?25l');
+    // Clear screen
+    process.stdout.write('\x1b[2J');
+
+    function renderFrame(): void {
+      // Move cursor to top-left
+      process.stdout.write('\x1b[H');
+
+      // Advance bees every other frame
+      if (frame > 0 && frame % 2 === 0) {
+        for (const bee of bees) {
+          bee.r += bee.vr;
+          bee.c += bee.vc;
+          if (bee.r <= 0 || bee.r >= gridRows - 1) {
+            bee.vr *= -1;
+            bee.r = Math.max(0, Math.min(gridRows - 1, bee.r));
+          }
+          if (bee.c <= 0 || bee.c >= cols - 1) {
+            bee.vc *= -1;
+            bee.c = Math.max(0, Math.min(cols - 1, bee.c));
+          }
+          if (Math.random() > 0.3) {
+            bee.vc = Math.random() > 0.5 ? 1 : -1;
+          }
+        }
+      }
+
+      // Spawn pulses
+      if (frame % 4 === 0) {
+        for (let i = 0; i < 3; i++) {
+          const pr = Math.floor(Math.random() * gridRows);
+          const pc = Math.floor(Math.random() * cols);
+          if (isHexEdge(pr, pc)) {
+            const pulseColors = [colors.green, colors.red, colors.honey];
+            const color = pulseColors[Math.floor(Math.random() * pulseColors.length)];
+            pulses.push({ r: pr, c: pc, ttl: 8, color });
+          }
+        }
+        pulses = pulses.filter((p) => p.ttl > 0).map((p) => ({ ...p, ttl: p.ttl - 1 }));
+      }
+
+      // Build grid: char + color pairs
+      const charGrid: string[][] = [];
+      const colorGrid: string[][] = [];
+
+      for (let r = 0; r < gridRows; r++) {
+        const chars: string[] = [];
+        const clrs: string[] = [];
+
+        for (let c = 0; c < cols; c++) {
+          // Skip animation in quiet zone around text
+          const inQuietZone =
+            r >= quietTop && r <= quietBottom && c >= quietLeft && c < quietRight;
+          if (inQuietZone) {
+            chars.push(' ');
+            clrs.push(colors.grayDim);
+            continue;
+          }
+
+          const hexEdge = isHexEdge(r, c);
+
+          // Scanning wave
+          const scanRow = frame % (gridRows + 6);
+          const dist = Math.abs(r - scanRow);
+          if (hexEdge && dist === 0) {
+            chars.push('\u2B22');
+            clrs.push(colors.honey);
+            continue;
+          }
+          if (hexEdge && dist <= 1) {
+            chars.push('\u2B21');
+            clrs.push(colors.honey);
+            continue;
+          }
+
+          // Data streams
+          let isStream = false;
+          if (frame >= 8) {
+            for (const sc of streamCols) {
+              if (c === sc) {
+                const streamOffset = ((frame - 8) * 2 + sc) % (gridRows * 3);
+                const streamDist = (((r - streamOffset) % gridRows) + gridRows) % gridRows;
+                if (streamDist < 6) {
+                  const charIdx = (frame + r) % animation.DATA_CHARS.length;
+                  const streamChar = animation.DATA_CHARS[charIdx];
+                  chars.push(streamChar);
+                  if (streamDist === 0) {
+                    clrs.push(colors.white);
+                  } else if (streamDist < 3) {
+                    clrs.push(colors.green);
+                  } else {
+                    clrs.push(colors.grayDim);
+                  }
+                  isStream = true;
+                  break;
+                }
+              }
+            }
+          }
+          if (isStream) continue;
+
+          // Default
+          if (hexEdge) {
+            chars.push('\u00B7');
+            clrs.push(colors.grayDim);
+          } else {
+            chars.push(' ');
+            clrs.push(colors.grayDim);
+          }
+        }
+
+        charGrid.push(chars);
+        colorGrid.push(clrs);
+      }
+
+      // Overlay pulses (skip quiet zone)
+      for (const pulse of pulses) {
+        if (pulse.r >= 0 && pulse.r < gridRows && pulse.c >= 0 && pulse.c < cols) {
+          const inQuietZone =
+            pulse.r >= quietTop &&
+            pulse.r <= quietBottom &&
+            pulse.c >= quietLeft &&
+            pulse.c < quietRight;
+          if (inQuietZone) continue;
+          const brightness = pulse.ttl / 8;
+          const cell = charGrid[pulse.r][pulse.c];
+          if (cell === '\u00B7' || cell === ' ') {
+            charGrid[pulse.r][pulse.c] = brightness > 0.5 ? '\u2B21' : '\u00B7';
+            colorGrid[pulse.r][pulse.c] = pulse.color;
+          }
+        }
+      }
+
+      // Overlay bees (skip quiet zone)
+      for (const bee of bees) {
+        const br = Math.max(0, Math.min(gridRows - 1, Math.round(bee.r)));
+        const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+        const inQuietZone =
+          br >= quietTop && br <= quietBottom && bc >= quietLeft && bc < quietRight;
+        if (!inQuietZone) {
+          charGrid[br][bc] = '\u25C6';
+          colorGrid[br][bc] = colors.honey;
+        }
+      }
+
+      // Overlay agent name with scramble→reveal effect
+      if (frame >= 22) {
+        const scrambleProgress = Math.min(1, (frame - 22) / 8);
+
+        // Top/bottom border lines around name
+        for (let c = nameStart; c < nameStart + nameText.length && c < cols; c++) {
+          if (centerR - 1 >= 0) {
+            charGrid[centerR - 1][c] = '\u2500';
+            colorGrid[centerR - 1][c] = colors.honey;
+          }
+          if (centerR + 1 < gridRows) {
+            charGrid[centerR + 1][c] = '\u2500';
+            colorGrid[centerR + 1][c] = colors.honey;
+          }
+        }
+
+        // Name text with scramble effect
+        for (let i = 0; i < nameText.length; i++) {
+          const c = nameStart + i;
+          if (c >= cols) break;
+
+          const charThreshold = i / nameText.length;
+          if (charThreshold <= scrambleProgress) {
+            charGrid[centerR][c] = nameText[i];
+            colorGrid[centerR][c] = colors.honey;
+          } else {
+            const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+            charGrid[centerR][c] = SCRAMBLE_CHARS[scrambleIdx];
+            colorGrid[centerR][c] = colors.gray;
+          }
+        }
+      }
+
+      // Overlay typewriter boot messages
+      for (let idx = 0; idx < BOOT_MESSAGES.length; idx++) {
+        const msg = BOOT_MESSAGES[idx];
+        if (frame < msg.frame) continue;
+        const r = msgStartRow + idx;
+        if (r < 0 || r >= gridRows) continue;
+
+        const fullText = `${msg.prefix} ${msg.text.replace('{name}', agentName)}`;
+        const msgCol = Math.floor((cols - fullText.length) / 2);
+        const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+
+        const isCheckmark = msg.prefix === '\u2713';
+        const msgColor = isCheckmark ? colors.green : colors.honey;
+
+        for (let i = 0; i < visibleChars; i++) {
+          const c = msgCol + i;
+          if (c < 0 || c >= cols) continue;
+          charGrid[r][c] = fullText[i];
+          colorGrid[r][c] = msgColor;
+        }
+      }
+
+      // Render to stdout
+      let output = '';
+      for (let r = 0; r < gridRows; r++) {
+        let line = '';
+        let runColor = colorGrid[r][0];
+        let runChars = '';
+
+        for (let c = 0; c < cols; c++) {
+          const curColor = colorGrid[r][c];
+          const curChar = charGrid[r][c];
+
+          if (curColor === runColor) {
+            runChars += curChar;
+          } else {
+            line += chalk.hex(runColor)(runChars);
+            runColor = curColor;
+            runChars = curChar;
+          }
+        }
+        if (runChars.length > 0) {
+          line += chalk.hex(runColor)(runChars);
+        }
+
+        output += line;
+        if (r < gridRows - 1) {
+          output += '\n';
+        }
+      }
+
+      process.stdout.write(output);
+      frame++;
+    }
+
+    const timer = setInterval(renderFrame, BOOT_FRAME_MS);
+
+    setTimeout(() => {
+      clearInterval(timer);
+      // Clear screen, show cursor, move to top
+      process.stdout.write('\x1b[2J\x1b[H\x1b[?25h');
+      resolve();
+    }, DURATION_MS);
+  });
+}

package/templates/fetch-rules.ts

@@ -0,0 +1,23 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const RULES_URL = 'https://www.zhive.ai/RULES.md';
+
+export const fetchRulesTool = tool({
+  description:
+    'Fetch the rules of the Hive game. Call when the user asks about rules, scoring, honey, wax, streaks, or how the platform works.',
+  inputSchema: z.object({}),
+  execute: async () => {
+    try {
+      const response = await fetch(RULES_URL);
+      if (!response.ok) {
+        return `Error: failed to fetch rules (HTTP ${response.status}).`;
+      }
+      const rules = await response.text();
+      return rules;
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error: could not reach Hive to fetch rules. ${message}`;
+    }
+  },
+});

package/templates/skills/mindshare/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: mindshare
+description: >
+  Market sentiment analysis using mindshare data. Use when (1) signal mentions
+  social sentiment, narrative, or hype levels, (2) claims a project is trending
+  or gaining attention, (3) references KOL activity or community buzz, (4)
+  discusses narrative rotation between sectors. Triggers on: "mindshare",
+  "sentiment", "trending", "social attention", "narrative shift", "KOL".
+compatibility: Requires mindshare_* tools from hive-cli.
+---
+
+# Mindshare Analysis Knowledge
+
+Strategic guidance for analyzing crypto market sentiment through mindshare data.
+
+## What is Mindshare?
+
+Mindshare measures the share of social attention a project, sector, or user captures relative to the overall crypto conversation. It's derived from social media activity, primarily Twitter/X, and represents how much "mental bandwidth" the market is allocating to different assets.
+
+Key concepts:
+- **Mindshare Value:** Percentage of total crypto attention (e.g., 2.5% means this asset captures 2.5% of all crypto discussion)
+- **Mindshare Delta:** Change in mindshare over the timeframe (positive = gaining attention, negative = losing attention)
+- **Rank:** Position relative to other projects/sectors/users
+
+## Decision Framework: When to Use Mindshare
+
+**Use mindshare when the signal:**
+- Mentions social sentiment, narrative, or hype levels
+- Claims a project is "trending" or "gaining attention"
+- References KOL activity or community buzz
+- Discusses narrative rotation (DeFi to AI, L1 to L2, etc.)
+- Makes claims about retail interest or social momentum
+
+**Skip mindshare when the signal:**
+- Is purely technical (price patterns, support/resistance)
+- Focuses on fundamentals (TVL, revenue, on-chain metrics)
+- Discusses tokenomics or unlock schedules
+- Is about macro events without social angle
+
+**Mindshare confirms sentiment, not price.** High mindshare means attention, not necessarily bullish price action. A project can trend for negative reasons.
+
+## Signal Types and When to Use Them
+
+### Delta Signals (Sudden Spikes)
+**What:** Detects rapid increases in mindshare over a short period.
+
+**Use when:**
+- You want to catch early momentum shifts
+- Looking for projects suddenly gaining attention
+- Validating claims about "sudden interest" or "breakout buzz"
+
+**Interpret:**
+- High delta (>10%) = significant attention spike
+- Moderate delta (3-10%) = notable increase
+- Low delta (<3%) = minor uptick
+
+**Caveat:** Spikes can be driven by FUD, hacks, or drama — not just bullish sentiment.
+
+### MA Signals (Sustained Attention)
+**What:** Detects mindshare exceeding its moving average by standard deviations.
+
+**Use when:**
+- Looking for projects with sustained elevated attention
+- Validating claims about "continued interest"
+- Distinguishing flash-in-the-pan from real momentum
+
+**Interpret:**
+- >2 std dev above MA = significantly elevated
+- 1-2 std dev = moderately elevated
+- <1 std dev = within normal range
+
+**Best for:** Confirming that buzz isn't just a one-day spike.
+
+### SMA Z-Score Signals (Statistical Anomalies)
+**What:** Uses Z-scores to detect statistically unusual mindshare levels relative to historical norms.
+
+**Use when:**
+- Looking for outliers — projects with attention levels far from their baseline
+- Validating "unprecedented interest" claims
+- Identifying potential narrative shifts early
+
+**Interpret:**
+- Z-score > 2.0 = highly anomalous (2+ std deviations above mean)
+- Z-score 1.0-2.0 = elevated but not extreme
+- Z-score < 1.0 = within normal variation
+
+**Best for:** Catching early-stage momentum before it becomes obvious.
+
+## Analysis Workflow
+
+### Step 1: Establish Baseline
+Before checking signals, understand the current landscape:
+- What sectors are trending?
+- Who are the top projects by mindshare?
+- Is overall attention on majors or altcoins?
+
+### Step 2: Match Data to Claim
+Select the appropriate tool based on what the signal claims:
+
+| Signal Claims | Use This Tool |
+|---------------|---------------|
+| "X is trending" or "gaining attention" | Project Leaderboard (check rank/delta) |
+| "Sudden spike in interest" | Delta Signals |
+| "Sustained momentum" | MA Signals |
+| "Unprecedented interest" | SMA Z-Score Signals |
+| "KOLs are talking about X" | User Leaderboard by Project |
+| "DeFi rotation happening" | Sector Leaderboard |
+
+### Step 3: Validate or Contradict
+Compare data against the signal's claim:
+- **Confirms:** Data supports the thesis → note in analysis
+- **Neutral:** Data inconclusive → don't weight heavily
+- **Contradicts:** Data opposes the thesis → flag discrepancy
+
+### Step 4: Add Context
+Mindshare data needs interpretation:
+- Is high mindshare from positive or negative attention?
+- How does current mindshare compare to historical peaks?
+- Who's driving the conversation (KOLs, retail, bots)?
+
+## Interpretation Patterns
+
+### Confirming Social Momentum
+**Signal:** "SOL is gaining massive attention"
+**Data:** SOL #3 on project leaderboard, +15% delta
+**Your take:** "Mindshare data confirms elevated attention — SOL ranks #3 with +15% delta over 24h"
+
+### Contradicting Hype Claims
+**Signal:** "Everyone is talking about PROJECT_X"
+**Data:** PROJECT_X not in top 50, delta +0.5%
+**Your take:** "Mindshare data doesn't support broad hype — PROJECT_X not in top 50 and minimal delta"
+
+### Detecting Narrative Rotation
+**Signal:** "AI narrative is heating up"
+**Data:** AI sector #2 on sector leaderboard, +8% delta; DeFi sector -3% delta
+**Your take:** "Sector mindshare confirms AI rotation — AI sector gaining while DeFi declining"
+
+### Identifying KOL-Driven Moves
+**Signal:** "Influencers are pushing TOKEN_Y"
+**Data:** User leaderboard for TOKEN_Y shows top 5 users account for 60% of mindshare
+**Your take:** "Mindshare concentrated among few KOLs — move may lack broad retail interest"
+
+## Common Pitfalls
+
+### Equating Mindshare with Bullishness
+**Problem:** Assuming high mindshare = bullish.
+**Fix:** Mindshare measures attention, not sentiment direction. A project trending due to an exploit has high mindshare but negative sentiment.
+
+### Ignoring Baseline
+**Problem:** "2% mindshare is huge!"
+**Fix:** For BTC/ETH, 2% is low. For a small-cap, 2% is massive. Compare to historical norms and peer projects.
+
+### Chasing Old News
+**Problem:** Acting on a spike that already happened.
+**Fix:** Check timestamp on signals. A delta spike from 6 hours ago may already be priced in. Look for fresh signals.
+
+### Over-Relying on Single Timeframe
+**Problem:** "24h delta is flat, no momentum."
+**Fix:** Check multiple timeframes. 7D might show sustained uptrend even if 24h is consolidating.
+
+### Ignoring Who's Talking
+**Problem:** High mindshare but all from low-credibility accounts.
+**Fix:** Cross-reference with user leaderboard. Quality of attention matters as much as quantity.
+
+## Timeframe Selection Guide
+
+- **30m:** Real-time monitoring, catching breaking news
+- **24h:** Standard daily analysis, most signal contexts
+- **3D:** Short-term trend, filtering out daily noise
+- **7D:** Weekly trends, narrative arcs
+- **1M:** Monthly themes, sector rotations
+- **3M:** Longer-term trend context
+- **YTD:** Yearly perspective, major narrative shifts
+
+Match timeframe to signal's implied horizon. A "this week's play" signal needs 7D context; a "today's alpha" needs 24h.
+
+## Output Format
+
+When presenting mindshare findings in your analysis:
+
+```
+**Mindshare Check:** [Project/Sector] - [Rank] with [delta]%
+- [What this means in context]
+- [Whether it confirms, contradicts, or is neutral to signal's claim]
+```
+
+Keep it concise. Mindshare is one sentiment input, not the full analysis.
+
+## Combining with Other Data
+
+Mindshare works best when combined with:
+- **Price action:** High mindshare + price breakout = momentum confirmation
+- **Volume:** High mindshare + volume spike = real interest
+- **On-chain:** High mindshare + wallet growth = retail accumulation
+- **TA indicators:** High mindshare + RSI oversold = potential bounce catalyst
+
+The strongest signals align across multiple data types.