hive-rank 3.0.0

package/README.md

@@ -0,0 +1,76 @@
+# hive-rank
+
+Crowdsourced SEO intelligence for AI agents.
+
+## What is this?
+
+Hive Rank aggregates anonymized search data from Claude Code agents into a shared ranking dataset. Every participant benefits from the collective intelligence of the network.
+
+**AI agents are searching for your product right now. Do you know where you rank?**
+
+## Install
+
+```bash
+npx hive-rank
+```
+
+Or add the MCP server directly:
+
+```bash
+claude mcp add --transport sse hive-rank https://mcp.hive-rank.com/mcp
+```
+
+## What you get
+
+### 6 MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `hive_rankings` | Aggregated rankings from the network for a query |
+| `hive_trending` | Trending queries across the network |
+| `hive_domain` | Network intelligence for a domain |
+| `hive_stats` | Network-wide statistics |
+| `hive_contributors` | Contributor activity stats |
+| `hive_search` | Full-text search across network queries |
+
+### 15 Slash Commands
+
+Research commands that generate data for the network:
+
+- `/hive:kickstart [domain]` — Bootstrap your SEO research
+- `/hive:baseline [domain] [keywords...]` — Establish baseline rankings
+- `/hive:grow [domain]` — Weekly growth check
+- `/hive:spy [competitor]` — Deep competitor analysis
+- `/hive:content [topic]` — Generate SEO content brief
+
+Network intelligence commands:
+
+- `/hive:rankings [query]` — Check network ranking data
+- `/hive:trends` — See what's trending
+- `/hive:status` — Network status and your contribution stats
+- `/hive:help` — Full command reference
+
+## How it works
+
+1. **You search** — Every WebSearch and WebFetch captures SEO data
+2. **Hook contributes** — Anonymized data flows to the network
+3. **Network grows** — Aggregated insights become available
+4. **Everyone benefits** — Richer data for all agents
+
+## Privacy
+
+- **Identity**: SHA-256 hash of a random UUID. No accounts, no emails.
+- **Timestamps**: Bucketed to date-only (YYYY-MM-DD). No session correlation.
+- **Data**: Only public search results — queries, URLs, positions, titles, snippets.
+
+We couldn't identify you even if we wanted to.
+
+## Links
+
+- **Dashboard**: https://www.hive-rank.com/dashboard
+- **Documentation**: https://www.hive-rank.com/docs
+- **GitHub**: https://github.com/lil-serp/grow-your-shit
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+/**
+ * Hive Rank — Installer
+ *
+ * Pure Node.js installer (zero external deps).
+ *
+ * Usage:
+ *   node bin/install.js          # from repo clone
+ *   npx hive-rank                # from npm (if published)
+ *
+ * Installs Hive Rank globally to ~/.hive-rank/ and configures
+ * Claude Code hooks, remote MCP server, and slash commands.
+ *
+ * No native dependencies — no npm install needed.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import readline from 'readline';
+import crypto from 'crypto';
+
+// ── Constants ──────────────────────────────────────────────────────────────────
+
+const HOME = os.homedir();
+const INSTALL_DIR = path.join(HOME, '.hive-rank');
+const CLAUDE_DIR = path.join(HOME, '.claude');
+const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
+const COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands', 'hive');
+const PKG_ROOT = path.resolve(new URL('..', import.meta.url).pathname);
+
+const HOOK_CMD = `node ${path.join(INSTALL_DIR, 'dist', 'hooks', 'capture-seo-data.js')}`;
+const MCP_NAME = 'hive-rank';
+const MCP_URL = 'https://mcp.hive-rank.com/mcp';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function log(msg) { console.log(`  ${msg}`); }
+function success(msg) { console.log(`  [ok] ${msg}`); }
+function warn(msg) { console.log(`  [warn] ${msg}`); }
+function fail(msg) { console.error(`  [error] ${msg}`); process.exit(1); }
+function dryLog(msg) { console.log(`  [dry-run] ${msg}`); }
+
+function fileExists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+function writeJsonAtomic(p, obj) {
+  const tmp = p + '.tmp.' + crypto.randomBytes(4).toString('hex');
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+  fs.renameSync(tmp, p);
+}
+
+function copyRecursive(src, dest) {
+  if (!fileExists(src)) return;
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+  } else {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
+}
+
+async function ask(question) {
+  if (!process.stdin.isTTY) return null;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`  ${question} `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function hasClaudeCli() {
+  try {
+    const result = spawnSync('claude', ['--version'], { stdio: 'pipe', timeout: 5000 });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function registerMcpServer() {
+  if (hasClaudeCli()) {
+    // Remove old entries from all scopes
+    for (const oldName of [MCP_NAME, 'gys-local', 'hive-seo', 'grow-your-shit']) {
+      spawnSync('claude', ['mcp', 'remove', '--scope', 'user', oldName], { stdio: 'pipe' });
+      spawnSync('claude', ['mcp', 'remove', oldName], { stdio: 'pipe' });
+    }
+
+    // Register remote MCP server via SSE
+    const result = spawnSync(
+      'claude',
+      ['mcp', 'add', '--scope', 'user', '--transport', 'sse', MCP_NAME, MCP_URL],
+      { stdio: 'pipe', timeout: 10000 }
+    );
+
+    if (result.status === 0) return 'cli';
+    warn(`claude mcp add failed: ${result.stderr?.toString().trim()}`);
+  }
+
+  // Fallback: write to ~/.claude.json
+  const claudeJson = path.join(HOME, '.claude.json');
+  let config = {};
+  if (fileExists(claudeJson)) {
+    try {
+      config = readJson(claudeJson);
+    } catch {
+      warn('~/.claude.json exists but is not valid JSON. Skipping MCP registration.');
+      return 'skipped';
+    }
+  }
+
+  // Clean up old entries
+  if (config.mcpServers) {
+    for (const oldName of ['gys-local', 'hive-seo', 'grow-your-shit', MCP_NAME]) {
+      delete config.mcpServers[oldName];
+    }
+  }
+
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers[MCP_NAME] = {
+    type: 'sse',
+    url: MCP_URL
+  };
+
+  writeJsonAtomic(claudeJson, config);
+  return 'direct';
+}
+
+function removeMcpServer() {
+  if (hasClaudeCli()) {
+    for (const oldName of [MCP_NAME, 'gys-local', 'hive-seo', 'grow-your-shit']) {
+      spawnSync('claude', ['mcp', 'remove', '--scope', 'user', oldName], { stdio: 'pipe' });
+      spawnSync('claude', ['mcp', 'remove', oldName], { stdio: 'pipe' });
+    }
+    return;
+  }
+
+  const claudeJson = path.join(HOME, '.claude.json');
+  if (fileExists(claudeJson)) {
+    try {
+      const config = readJson(claudeJson);
+      let changed = false;
+      if (config.mcpServers) {
+        for (const oldName of [MCP_NAME, 'gys-local', 'hive-seo', 'grow-your-shit']) {
+          if (config.mcpServers[oldName]) { delete config.mcpServers[oldName]; changed = true; }
+        }
+      }
+      if (changed) writeJsonAtomic(claudeJson, config);
+    } catch { /* ignore */ }
+  }
+}
+
+function configureHook() {
+  fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+
+  let settings = {};
+  if (fileExists(SETTINGS_FILE)) {
+    try {
+      fs.copyFileSync(SETTINGS_FILE, SETTINGS_FILE + '.backup');
+      settings = readJson(SETTINGS_FILE);
+    } catch {
+      warn('Could not parse ~/.claude/settings.json — creating backup and starting fresh');
+      if (fileExists(SETTINGS_FILE)) {
+        fs.copyFileSync(SETTINGS_FILE, SETTINGS_FILE + '.corrupt.' + Date.now());
+      }
+      settings = {};
+    }
+  }
+
+  // Clean up old mcpServers (shouldn't be in settings.json)
+  if (settings.mcpServers) {
+    for (const oldName of ['gys-local', 'hive-seo', MCP_NAME]) {
+      delete settings.mcpServers[oldName];
+    }
+    if (Object.keys(settings.mcpServers).length === 0) delete settings.mcpServers;
+  }
+
+  // Remove old hook entries
+  if (settings.hooks?.PostToolUse) {
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter((entry) => {
+      const cmd = entry.command || '';
+      const nestedCmds = (entry.hooks || []).map(h => h.command || '').join(' ');
+      const allCmds = cmd + ' ' + nestedCmds;
+      return !allCmds.includes('hive-seo') &&
+             !allCmds.includes('hive-rank') &&
+             !allCmds.includes('grow-your-shit');
+    });
+    if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+  }
+
+  // Add hook
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+  settings.hooks.PostToolUse.push({
+    matcher: 'WebSearch|WebFetch',
+    hooks: [{ type: 'command', command: HOOK_CMD }]
+  });
+
+  writeJsonAtomic(SETTINGS_FILE, settings);
+}
+
+function removeHook() {
+  if (!fileExists(SETTINGS_FILE)) return;
+
+  try {
+    const settings = readJson(SETTINGS_FILE);
+    if (settings.hooks?.PostToolUse) {
+      settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter((entry) => {
+        const cmd = entry.command || '';
+        const nestedCmds = (entry.hooks || []).map(h => h.command || '').join(' ');
+        const allCmds = cmd + ' ' + nestedCmds;
+        return !allCmds.includes('hive-seo') &&
+               !allCmds.includes('hive-rank') &&
+               !allCmds.includes('grow-your-shit');
+      });
+      if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+      if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
+    }
+
+    if (settings.mcpServers) {
+      for (const oldName of ['gys-local', 'hive-seo', MCP_NAME]) {
+        delete settings.mcpServers[oldName];
+      }
+      if (Object.keys(settings.mcpServers).length === 0) delete settings.mcpServers;
+    }
+
+    writeJsonAtomic(SETTINGS_FILE, settings);
+  } catch { /* ignore */ }
+}
+
+// ── Parse args ─────────────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const FLAG_FORCE = args.includes('--force');
+const FLAG_UNINSTALL = args.includes('--uninstall');
+const FLAG_DRY_RUN = args.includes('--dry-run');
+const FLAG_HELP = args.includes('--help') || args.includes('-h');
+
+if (FLAG_HELP) {
+  console.log(`
+  Hive Rank — Crowdsourced SEO intelligence for AI agents
+
+  Usage:
+    node bin/install.js              Install from repo clone
+    node bin/install.js --force      Reinstall (overwrite existing)
+    node bin/install.js --uninstall  Remove Hive Rank completely
+    node bin/install.js --dry-run    Preview changes without writing
+    node bin/install.js --help       Show this help
+
+  What it does:
+    1. Copies dist + commands to ~/.hive-rank/
+    2. Registers hooks in ~/.claude/settings.json
+    3. Registers remote MCP server via \`claude mcp add\` (SSE transport)
+    4. Installs slash commands to ~/.claude/commands/hive/
+
+  Config locations:
+    Hooks:      ~/.claude/settings.json
+    MCP server: ~/.claude.json (via \`claude mcp add --scope user\`)
+    Commands:   ~/.claude/commands/hive/*.md
+`);
+  process.exit(0);
+}
+
+// ── Uninstall ──────────────────────────────────────────────────────────────────
+
+if (FLAG_UNINSTALL) {
+  if (FLAG_DRY_RUN) {
+    console.log('\n  Uninstalling Hive Rank — DRY RUN (no changes will be made)\n');
+    dryLog('Would remove hooks from ' + SETTINGS_FILE);
+    dryLog('Would remove MCP server');
+    if (fileExists(COMMANDS_DIR)) dryLog('Would remove slash commands: ' + COMMANDS_DIR);
+    if (fileExists(INSTALL_DIR)) dryLog('Would remove ' + INSTALL_DIR + '/');
+    console.log('\n  Dry run complete — no changes were made.\n');
+    process.exit(0);
+  }
+
+  console.log('\n  Uninstalling Hive Rank...\n');
+
+  removeHook();
+  success('Removed hooks from settings.json');
+
+  removeMcpServer();
+  success('Removed MCP server');
+
+  // Remove old gys commands too
+  const oldCommandsDir = path.join(CLAUDE_DIR, 'commands', 'gys');
+  if (fileExists(oldCommandsDir)) {
+    fs.rmSync(oldCommandsDir, { recursive: true, force: true });
+    success('Removed old /gys:* commands');
+  }
+
+  if (fileExists(COMMANDS_DIR)) {
+    fs.rmSync(COMMANDS_DIR, { recursive: true, force: true });
+    success('Removed slash commands');
+  }
+
+  if (fileExists(INSTALL_DIR)) {
+    fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
+    success('Removed ~/.hive-rank/');
+  }
+
+  // Clean up old install dirs
+  for (const oldDir of ['.grow-your-shit', '.hive-seo']) {
+    const oldPath = path.join(HOME, oldDir);
+    if (fileExists(oldPath)) {
+      fs.rmSync(oldPath, { recursive: true, force: true });
+      success(`Removed ~/${oldDir}/`);
+    }
+  }
+
+  console.log('\n  Hive Rank has been uninstalled. Restart Claude Code to apply.\n');
+  process.exit(0);
+}
+
+// ── Install ────────────────────────────────────────────────────────────────────
+
+async function install() {
+  if (FLAG_DRY_RUN) {
+    console.log('\n  Hive Rank — DRY RUN (no changes will be made)\n');
+  } else {
+    console.log('\n  Hive Rank — Crowdsourced SEO intelligence for AI agents\n');
+  }
+
+  // Preflight: check dist/ exists
+  const distDir = path.join(PKG_ROOT, 'dist');
+  if (!fileExists(distDir)) {
+    fail('dist/ not found. Run `pnpm run build` first, then `node bin/install.js`.');
+  }
+
+  // Check for existing installation
+  if (fileExists(INSTALL_DIR) && !FLAG_FORCE && !FLAG_DRY_RUN) {
+    const answer = await ask('Existing installation found. Overwrite? (y/N)');
+    if (!answer || answer.toLowerCase() !== 'y') {
+      log('Use --force to overwrite. Aborting.');
+      process.exit(0);
+    }
+  }
+
+  // Preserve existing contributorId
+  let existingContributorId = null;
+  const configPaths = [
+    path.join(INSTALL_DIR, 'dist', 'hooks', 'config.json'),
+    path.join(HOME, '.grow-your-shit', 'dist', 'hooks', 'config.json'),
+    path.join(HOME, '.hive-seo', 'dist', 'hooks', 'config.json')
+  ];
+  for (const configPath of configPaths) {
+    if (!existingContributorId && fileExists(configPath)) {
+      try {
+        const existingConfig = readJson(configPath);
+        existingContributorId = existingConfig?.contributorId ||
+                               existingConfig?.hive?.contributorId;
+      } catch { /* ignore */ }
+    }
+  }
+
+  // ── Step 1: Copy package files ──
+
+  if (FLAG_DRY_RUN) {
+    dryLog(`Would copy dist/ to ${INSTALL_DIR}/dist/`);
+    dryLog(`Would copy commands/ to ${INSTALL_DIR}/commands/`);
+    dryLog(`Would copy bin/install.js to ${INSTALL_DIR}/bin/install.js`);
+  } else {
+    log('Copying files to ~/.hive-rank/ ...');
+
+    if (fileExists(INSTALL_DIR)) {
+      fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
+    }
+    fs.mkdirSync(INSTALL_DIR, { recursive: true });
+
+    copyRecursive(path.join(PKG_ROOT, 'dist'), path.join(INSTALL_DIR, 'dist'));
+    copyRecursive(path.join(PKG_ROOT, 'commands'), path.join(INSTALL_DIR, 'commands'));
+
+    const installerDest = path.join(INSTALL_DIR, 'bin');
+    fs.mkdirSync(installerDest, { recursive: true });
+    fs.copyFileSync(
+      path.join(PKG_ROOT, 'bin', 'install.js'),
+      path.join(installerDest, 'install.js')
+    );
+
+    const pkgVersion = readJson(path.join(PKG_ROOT, 'package.json')).version || '0.0.0';
+    writeJsonAtomic(path.join(INSTALL_DIR, 'version.json'), {
+      version: pkgVersion,
+      installedAt: new Date().toISOString()
+    });
+
+    success('Files copied');
+  }
+
+  // ── Step 2: Write hooks config ──
+
+  const hooksConfigDir = path.join(INSTALL_DIR, 'dist', 'hooks');
+  const hooksConfigPath = path.join(hooksConfigDir, 'config.json');
+  const contributorId = existingContributorId || crypto.randomUUID();
+
+  if (FLAG_DRY_RUN) {
+    dryLog(`Would write hook config to ${hooksConfigPath}`);
+    dryLog(`  contributorId: ${existingContributorId ? 'preserved' : 'new'}`);
+  } else {
+    fs.mkdirSync(hooksConfigDir, { recursive: true });
+    writeJsonAtomic(hooksConfigPath, {
+      enabled: true,
+      endpoint: 'https://mcp.hive-rank.com/api/contribute',
+      contributorId: contributorId
+    });
+    success('Hook config written');
+  }
+
+  // ── Step 3: Register MCP server ──
+
+  if (FLAG_DRY_RUN) {
+    if (hasClaudeCli()) {
+      dryLog(`Would run: claude mcp add --scope user --transport sse ${MCP_NAME} ${MCP_URL}`);
+    } else {
+      dryLog('Would register MCP server in ~/.claude.json');
+    }
+  } else {
+    log('Registering remote MCP server...');
+    const mcpMethod = registerMcpServer();
+    if (mcpMethod === 'cli') {
+      success('MCP server registered via `claude mcp add` (SSE transport)');
+    } else if (mcpMethod === 'direct') {
+      success('MCP server registered in ~/.claude.json');
+    } else {
+      warn('MCP server registration skipped — run manually after install');
+    }
+  }
+
+  // ── Step 4: Configure hook ──
+
+  if (FLAG_DRY_RUN) {
+    dryLog(`Would add PostToolUse hook to ${SETTINGS_FILE}`);
+  } else {
+    log('Configuring PostToolUse hook...');
+    configureHook();
+    success('Hook configured in ~/.claude/settings.json');
+  }
+
+  // ── Step 5: Install slash commands ──
+
+  // Remove old gys commands
+  const oldCommandsDir = path.join(CLAUDE_DIR, 'commands', 'gys');
+  if (!FLAG_DRY_RUN && fileExists(oldCommandsDir)) {
+    fs.rmSync(oldCommandsDir, { recursive: true, force: true });
+    log('Removed old /gys:* commands');
+  }
+
+  if (FLAG_DRY_RUN) {
+    const commandsSource = path.join(PKG_ROOT, 'commands');
+    if (fileExists(commandsSource)) {
+      const cmdFiles = fs.readdirSync(commandsSource).filter(f => f.endsWith('.md'));
+      dryLog(`Would install ${cmdFiles.length} slash commands to ${COMMANDS_DIR}/`);
+    }
+  } else {
+    log('Installing slash commands...');
+    fs.mkdirSync(COMMANDS_DIR, { recursive: true });
+
+    const commandsSource = path.join(INSTALL_DIR, 'commands');
+    if (fileExists(commandsSource)) {
+      for (const file of fs.readdirSync(commandsSource)) {
+        if (file.endsWith('.md')) {
+          fs.copyFileSync(
+            path.join(commandsSource, file),
+            path.join(COMMANDS_DIR, file)
+          );
+        }
+      }
+      success('Slash commands installed to ~/.claude/commands/hive/');
+    }
+  }
+
+  // ── Done ──
+
+  if (FLAG_DRY_RUN) {
+    console.log(`
+  ────────────────────────────────────────────────
+  Dry run complete — no changes were made.
+  ────────────────────────────────────────────────
+
+  Run without --dry-run to apply these changes:
+    node ${path.join(PKG_ROOT, 'bin', 'install.js')}${FLAG_FORCE ? ' --force' : ''}
+  `);
+  } else {
+    console.log(`
+  ────────────────────────────────────────────────
+  Hive Rank installed successfully!
+  ────────────────────────────────────────────────
+
+  Restart Claude Code, then try:
+
+    /hive:help       — See all commands
+    /hive:kickstart  — Bootstrap your SEO research
+    /hive:rankings   — Check ranking data
+    /hive:trends     — See what's trending
+
+  Config:
+    Hooks:      ${SETTINGS_FILE}
+    MCP server: ${MCP_URL} (via SSE)
+    Commands:   ${COMMANDS_DIR}/
+
+  To uninstall: node ~/.hive-rank/bin/install.js --uninstall
+  `);
+  }
+}
+
+install().catch((e) => {
+  fail(e.message);
+});

package/commands/audit-site.md

@@ -0,0 +1,47 @@
+---
+name: audit-site
+description: Run a technical SEO audit on a website
+allowed-tools:
+  - mcp: hive-rank
+    tools:
+      - hive_domain
+      - hive_search
+      - hive_rankings
+---
+
+Run a technical SEO audit for: $ARGUMENTS
+
+If no domain is specified, ask the user which site to audit.
+
+**Step 1 — Establish Search Presence:**
+- WebSearch the brand name to check brand SERP
+- WebSearch 3-5 key product/service terms the domain should rank for
+- WebSearch "site:[domain]" to check indexation breadth
+- Use `hive_domain` to get network data on this domain
+
+**Step 2 — Analyze Content & Metadata:**
+- WebFetch the homepage and 3-5 key pages
+- Review the WebFetch responses for:
+  - Unique titles (not duplicate)
+  - Meta descriptions present and compelling
+  - H1 tags present and keyword-aligned
+  - Content depth and quality
+- Note any duplicate or missing metadata
+
+**Step 3 — Check Competitive Position:**
+- Use `hive_search` to find related queries in the network
+- Use `hive_rankings` on key queries to compare positions
+- Identify who else appears for the same queries
+
+**Step 4 — Synthesize Findings:**
+
+IMPORTANT: Do NOT dump raw data. Synthesize into a narrative audit report.
+
+Present findings in three priority tiers:
+- **Critical issues** (blocking growth) — e.g., missing from brand SERP, major indexation problems
+- **Warnings** (leaving value on the table) — e.g., weak titles, missing descriptions
+- **Opportunities** (quick wins) — e.g., content format mismatches, underoptimized pages
+
+End with **3-5 specific, actionable next steps** prioritized by impact.
+
+Each search contributes to the network, building audit insights for everyone.

package/commands/audit.md

@@ -0,0 +1,22 @@
+---
+name: audit
+description: Check your contribution status and network health
+allowed-tools:
+  - mcp: hive-rank
+    tools:
+      - hive_stats
+      - hive_contributors
+---
+
+Check the health of my Hive Rank contribution status.
+
+Use `hive_stats` to get network statistics. Then give me a plain-English summary:
+
+- Network size (contributors, observations)
+- My contribution status (if visible in stats)
+- Recent activity across the network
+- Whether my contributions are flowing properly
+
+If you can access `hive_contributors`, show where I stand in the network.
+
+Keep it short and actionable. If there are issues, explain how to troubleshoot.