@hive-org/cli 0.0.1

package/templates/chat-prompt.ts

@@ -0,0 +1,94 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatContext {
+  recentThreadSummaries: string[];
+  recentPredictions: string[];
+  sessionMessages: ChatMessage[];
+  memory: string;
+  userMessage: string;
+}
+
+async function loadMarkdownFile(filename: string): Promise<string> {
+  const filePath = path.join(process.cwd(), filename);
+  const content = await fs.readFile(filePath, 'utf-8');
+  return content;
+}
+
+function extractSections(content: string): string[] {
+  const sections = content
+    .split('\n')
+    .filter((line) => line.trim().startsWith('## '))
+    .map((line) => line.trim().replace(/^## /, ''));
+  return sections;
+}
+
+export async function buildChatPrompt(context: ChatContext): Promise<string> {
+  const soulContent = await loadMarkdownFile('SOUL.md');
+  const strategyContent = await loadMarkdownFile('STRATEGY.md');
+
+  let threadsSection = '';
+  if (context.recentThreadSummaries.length > 0) {
+    const listed = context.recentThreadSummaries.map((t) => `- ${t}`).join('\n');
+    threadsSection = `\n## Recent Signals\n\n${listed}\n`;
+  }
+
+  let predictionsSection = '';
+  if (context.recentPredictions.length > 0) {
+    const listed = context.recentPredictions.map((p) => `- ${p}`).join('\n');
+    predictionsSection = `\n## Recent Predictions\n\n${listed}\n`;
+  }
+
+  let memorySection = '';
+  if (context.memory.trim().length > 0) {
+    memorySection = `\n## Past Conversations\n\nThings you remember from previous sessions with your operator:\n${context.memory}\n`;
+  }
+
+  let sessionSection = '';
+  if (context.sessionMessages.length > 0) {
+    const listed = context.sessionMessages
+      .map((m) => `${m.role === 'user' ? 'User' : 'You'}: ${m.content}`)
+      .join('\n');
+    sessionSection = `\n## This Session's Conversation\n\n${listed}\n`;
+  }
+
+  const prompt = `You are an AI trading agent having a conversation with your operator. Stay in character.
+
+Your personality:
+---
+${soulContent}
+---
+
+Your trading strategy:
+---
+${strategyContent}
+---
+${memorySection}${threadsSection}${predictionsSection}${sessionSection}
+The operator says: "${context.userMessage}"
+
+## Editing Your Files
+
+You have a tool called "editSection" that can update sections of your SOUL.md and STRATEGY.md.
+
+Rules:
+1. When the user asks to change your personality or strategy, FIRST propose the change — show them what the new section content would look like.
+2. Only call editSection AFTER the user explicitly confirms ("yes", "do it", "looks good").
+3. Never call the tool speculatively.
+4. After applying, confirm briefly in character.
+
+SOUL.md sections: ${extractSections(soulContent).join(', ')}
+STRATEGY.md sections: ${extractSections(strategyContent).join(', ')}
+
+## Game Rules
+
+You have a tool called "fetchRules" that fetches the official Hive game rules. Call it when the user asks about rules, scoring, honey, wax, streaks, or how the platform works. Summarize the rules in your own voice — don't dump the raw markdown.
+
+Respond in character. Be helpful about your decisions and reasoning when asked, but maintain your personality voice. Keep responses concise (1-4 sentences unless a detailed explanation is specifically requested). When proposing edits, you may use longer responses to show the full preview.`;
+
+  return prompt;
+}

package/templates/components/AsciiTicker.tsx

@@ -0,0 +1,113 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { colors, animation } from '../theme';
+
+interface AsciiTickerProps {
+  rows?: 1 | 2;
+  step?: number;
+}
+
+interface Segment {
+  char: string;
+  color: string;
+}
+
+function buildTickerChars(step: number): string {
+  const stepStr = String(step).padStart(2, '0');
+  const digits = stepStr.split('');
+  return animation.HEX_CHARS + digits.join('') + '\u25AA\u25AB\u2591\u2592';
+}
+
+function buildRow(cols: number, frame: number, rowIndex: number, tickerChars: string): Segment[] {
+  const segments: Segment[] = [];
+  const isSecondRow = rowIndex === 1;
+  const scrollSpeed = isSecondRow ? 3 : 2;
+  const direction = isSecondRow ? -1 : 1;
+  const sinFreq = isSecondRow ? 0.4 : 0.3;
+  const sinPhase = isSecondRow ? -0.4 : 0.6;
+  const wrapLen = cols * 2;
+
+  for (let c = 0; c < cols; c++) {
+    const scrolledC = ((direction === 1)
+      ? (c + frame * scrollSpeed) % wrapLen
+      : (cols - c + frame * scrollSpeed) % wrapLen);
+
+    const charIdx = scrolledC % tickerChars.length;
+    const char = tickerChars[charIdx];
+    const isHex = char === '\u2B21' || char === '\u2B22';
+    const pulseHit = Math.sin((c + frame * sinPhase) * sinFreq) > 0.5;
+
+    // Edge fade: dim the outermost 4 columns
+    const edgeDist = Math.min(c, cols - 1 - c);
+    if (edgeDist < 2) {
+      segments.push({ char: '\u00B7', color: colors.grayDim });
+      continue;
+    }
+    if (edgeDist < 4) {
+      segments.push({ char, color: colors.grayDim });
+      continue;
+    }
+
+    if (pulseHit && isHex) {
+      segments.push({ char, color: colors.honey });
+    } else if (pulseHit) {
+      segments.push({ char, color: colors.green });
+    } else {
+      segments.push({ char, color: colors.grayDim });
+    }
+  }
+
+  return segments;
+}
+
+function renderSegments(segments: Segment[]): React.ReactElement[] {
+  const elements: React.ReactElement[] = [];
+  let runColor = segments[0]?.color ?? colors.grayDim;
+  let runChars = '';
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.color === runColor) {
+      runChars += seg.char;
+    } else {
+      elements.push(
+        <Text key={`${elements.length}`} color={runColor}>{runChars}</Text>,
+      );
+      runColor = seg.color;
+      runChars = seg.char;
+    }
+  }
+
+  if (runChars.length > 0) {
+    elements.push(
+      <Text key={`${elements.length}`} color={runColor}>{runChars}</Text>,
+    );
+  }
+
+  return elements;
+}
+
+export function AsciiTicker({ rows = 1, step = 1 }: AsciiTickerProps): React.ReactElement {
+  const [frame, setFrame] = useState(0);
+  const cols = process.stdout.columns || 60;
+  const tickerChars = buildTickerChars(step);
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => prev + 1);
+    }, animation.TICK_MS);
+
+    return () => {
+      clearInterval(timer);
+    };
+  }, []);
+
+  return (
+    <Box flexDirection="column">
+      <Text>{renderSegments(buildRow(cols, frame, 0, tickerChars))}</Text>
+      {rows === 2 && (
+        <Text>{renderSegments(buildRow(cols, frame, 1, tickerChars))}</Text>
+      )}
+    </Box>
+  );
+}

package/templates/components/HoneycombBoot.tsx

@@ -0,0 +1,348 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+import { colors, animation } from '../theme';
+
+const BOOT_TOTAL_FRAMES = 58;
+const BOOT_FRAME_MS = 80;
+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 hive...', 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;
+}
+
+interface Cell {
+  char: string;
+  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;
+}
+
+function compressRow(row: Cell[]): { text: string; color: string }[] {
+  if (row.length === 0) return [];
+  const segments: { text: string; color: string }[] = [];
+  let current = { text: row[0].char, color: row[0].color };
+  for (let i = 1; i < row.length; i++) {
+    if (row[i].color === current.color) {
+      current.text += row[i].char;
+    } else {
+      segments.push(current);
+      current = { text: row[i].char, color: row[i].color };
+    }
+  }
+  segments.push(current);
+  return segments;
+}
+
+function initBees(rows: number, cols: number): Bee[] {
+  const bees: Bee[] = [];
+  for (let i = 0; i < NUM_BEES; i++) {
+    bees.push({
+      r: Math.floor(Math.random() * rows),
+      c: Math.floor(Math.random() * cols),
+      vr: Math.random() > 0.5 ? 1 : -1,
+      vc: Math.random() > 0.5 ? 1 : -1,
+    });
+  }
+  return bees;
+}
+
+function initStreamCols(cols: number): number[] {
+  const streamCols: number[] = [];
+  const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+  for (let i = 1; i <= NUM_STREAMS; i++) {
+    streamCols.push(spacing * i);
+  }
+  return streamCols;
+}
+
+// ─── Grid builder ────────────────────────────────────
+
+function buildHoneycombGrid(
+  cols: number,
+  rows: number,
+  frame: number,
+  agentName: string,
+  bees: Bee[],
+  streamCols: number[],
+  pulses: Pulse[],
+): Cell[][] {
+  const centerR = Math.floor(rows / 2) - 2;
+  const centerC = Math.floor(cols / 2);
+
+  // Initialize empty grid
+  const grid: Cell[][] = [];
+  for (let r = 0; r < rows; r++) {
+    const row: Cell[] = [];
+    for (let c = 0; c < cols; c++) {
+      row.push({ char: ' ', color: colors.grayDim });
+    }
+    grid.push(row);
+  }
+
+  // ── Layer 1: Hex skeleton base ──
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      if (isHexEdge(r, c)) {
+        grid[r][c] = { char: '\u00B7', color: colors.grayDim };
+      }
+    }
+  }
+
+  // ── Layer 2: Scanning wave ──
+  const scanRow = frame % (rows + 6);
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      if (!isHexEdge(r, c)) continue;
+      const dist = Math.abs(r - scanRow);
+      if (dist === 0) {
+        grid[r][c] = { char: '\u2B22', color: colors.honey };
+      } else if (dist <= 1) {
+        grid[r][c] = { char: '\u2B21', color: colors.honey };
+      }
+    }
+  }
+
+  // ── Layer 3: Vertical data streams ──
+  if (frame >= 8) {
+    const streamPhase = frame - 8;
+    for (const sc of streamCols) {
+      if (sc >= cols) continue;
+      for (let r = 0; r < rows; r++) {
+        const streamOffset = (streamPhase * 2 + sc) % (rows * 3);
+        const streamDist = (((r - streamOffset) % rows) + rows) % rows;
+        if (streamDist < 6) {
+          const charIdx = (frame + r) % animation.DATA_CHARS.length;
+          const streamChar = animation.DATA_CHARS[charIdx];
+          let streamColor = colors.grayDim;
+          if (streamDist === 0) {
+            streamColor = colors.white;
+          } else if (streamDist < 3) {
+            streamColor = colors.green;
+          }
+          grid[r][sc] = { char: streamChar, color: streamColor };
+        }
+      }
+    }
+  }
+
+  // ── Layer 4: Pulse overlay ──
+  for (const pulse of pulses) {
+    if (pulse.r >= 0 && pulse.r < rows && pulse.c >= 0 && pulse.c < cols) {
+      const brightness = pulse.ttl / 8;
+      const cell = grid[pulse.r][pulse.c];
+      if (cell.char === '\u00B7' || cell.char === ' ') {
+        grid[pulse.r][pulse.c] = {
+          char: brightness > 0.5 ? '\u2B21' : '\u00B7',
+          color: pulse.color,
+        };
+      }
+    }
+  }
+
+  // ── Layer 5: Bee overlay ──
+  for (const bee of bees) {
+    const br = Math.max(0, Math.min(rows - 1, Math.round(bee.r)));
+    const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+    grid[br][bc] = { char: '\u25C6', color: colors.honey };
+  }
+
+  // ── Layer 6: Agent name with scramble→reveal ──
+  if (frame >= 22) {
+    const nameText = `\u2B21  ${agentName} agent  \u2B21`;
+    const nameStart = Math.max(0, centerC - Math.floor(nameText.length / 2));
+    const scrambleProgress = Math.min(1, (frame - 22) / 8);
+
+    // Clear space around the name
+    for (let c = nameStart - 2; c < nameStart + nameText.length + 2 && c < cols; c++) {
+      if (c >= 0) {
+        grid[centerR][c] = { char: ' ', color: colors.grayDim };
+        if (centerR - 1 >= 0) grid[centerR - 1][c] = { char: ' ', color: colors.grayDim };
+        if (centerR + 1 < rows) grid[centerR + 1][c] = { char: ' ', color: colors.grayDim };
+      }
+    }
+
+    // Top/bottom border lines around name
+    for (let c = nameStart; c < nameStart + nameText.length && c < cols; c++) {
+      if (centerR - 1 >= 0) grid[centerR - 1][c] = { char: '\u2500', color: colors.honey };
+      if (centerR + 1 < rows) grid[centerR + 1][c] = { char: '\u2500', color: 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) {
+        grid[centerR][c] = { char: nameText[i], color: colors.honey };
+      } else {
+        const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+        grid[centerR][c] = { char: SCRAMBLE_CHARS[scrambleIdx], color: colors.gray };
+      }
+    }
+  }
+
+  // ── Layer 7: Boot messages with typewriter ──
+  const msgStartRow = centerR + 4;
+  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 >= rows) continue;
+
+    const fullText = `${msg.prefix} ${msg.text.replace('{name}', agentName)}`;
+    const msgStart = Math.max(0, centerC - Math.floor(fullText.length / 2));
+    const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+
+    for (let i = 0; i < visibleChars; i++) {
+      const c = msgStart + i;
+      if (c >= cols) break;
+
+      const isCheckmark = msg.prefix === '\u2713';
+      grid[r][c] = { char: fullText[i], color: isCheckmark ? colors.green : colors.honey };
+    }
+  }
+
+  return grid;
+}
+
+// ─── Component ───────────────────────────────────────
+
+interface HoneycombBootProps {
+  agentName: string;
+  width: number;
+  onComplete: () => void;
+}
+
+export function HoneycombBoot({ agentName, width, onComplete }: HoneycombBootProps): React.ReactElement {
+  const [frame, setFrame] = useState(0);
+  const heightRef = useRef(process.stdout.rows || 24);
+  const completedRef = useRef(false);
+  const frameRef = useRef(0);
+  const beesRef = useRef<Bee[]>(initBees(heightRef.current, width));
+  const streamColsRef = useRef<number[]>(initStreamCols(width));
+  const pulsesRef = useRef<Pulse[]>([]);
+
+  useEffect(() => {
+    const tick = setInterval(() => {
+      const h = heightRef.current;
+      const f = frameRef.current;
+
+      // Advance bees every other frame
+      if (beesRef.current.length > 0 && f % 2 === 0) {
+        for (const bee of beesRef.current) {
+          bee.r += bee.vr;
+          bee.c += bee.vc;
+          if (bee.r <= 0 || bee.r >= h - 1) {
+            bee.vr *= -1;
+            bee.r = Math.max(0, Math.min(h - 1, bee.r));
+          }
+          if (bee.c <= 0 || bee.c >= width - 1) {
+            bee.vc *= -1;
+            bee.c = Math.max(0, Math.min(width - 1, bee.c));
+          }
+          if (Math.random() > 0.3) {
+            bee.vc = Math.random() > 0.5 ? 1 : -1;
+          }
+        }
+      }
+
+      // Spawn pulses every 4 frames
+      if (f % 4 === 0) {
+        const currentPulses = pulsesRef.current;
+        for (let i = 0; i < 3; i++) {
+          const pr = Math.floor(Math.random() * h);
+          const pc = Math.floor(Math.random() * width);
+          if (isHexEdge(pr, pc)) {
+            const pulseColors = [colors.green, colors.red, colors.honey];
+            const color = pulseColors[Math.floor(Math.random() * pulseColors.length)];
+            currentPulses.push({ r: pr, c: pc, ttl: 8, color });
+          }
+        }
+        pulsesRef.current = currentPulses
+          .filter((p) => p.ttl > 0)
+          .map((p) => ({ ...p, ttl: p.ttl - 1 }));
+      }
+
+      frameRef.current = f + 1;
+      setFrame(frameRef.current);
+
+      if (frameRef.current >= BOOT_TOTAL_FRAMES && !completedRef.current) {
+        completedRef.current = true;
+        clearInterval(tick);
+        setTimeout(onComplete, 300);
+      }
+    }, BOOT_FRAME_MS);
+
+    return () => {
+      clearInterval(tick);
+    };
+  }, [onComplete, width]);
+
+  const height = heightRef.current;
+  const clampedFrame = Math.min(frame, BOOT_TOTAL_FRAMES);
+  const grid = buildHoneycombGrid(
+    width,
+    height,
+    clampedFrame,
+    agentName,
+    beesRef.current,
+    streamColsRef.current,
+    pulsesRef.current,
+  );
+
+  return (
+    <Box flexDirection="column" height={height}>
+      {grid.map((row, r) => {
+        const segments = compressRow(row);
+        return (
+          <Box key={r} width={width}>
+            <Text>
+              {segments.map((seg, i) => (
+                <Text key={i} color={seg.color}>
+                  {seg.text}
+                </Text>
+              ))}
+            </Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}

package/templates/components/Spinner.tsx

@@ -0,0 +1,64 @@
+import React, { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { colors } from '../theme';
+
+const SPINNER_FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2'];
+
+export function Spinner({ label }: { label: string }): React.ReactElement {
+  const [frame, setFrame] = useState(0);
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, 120);
+    return () => {
+      clearInterval(timer);
+    };
+  }, []);
+
+  return (
+    <Text>
+      <Text color={colors.honey}>{SPINNER_FRAMES[frame]}</Text>
+      <Text color="gray"> {label}</Text>
+    </Text>
+  );
+}
+
+export function TypewriterText({
+  text,
+  color,
+  speed = 25,
+}: {
+  text: string;
+  color: string;
+  speed?: number;
+}): React.ReactElement {
+  const [visible, setVisible] = useState(0);
+
+  useEffect(() => {
+    if (visible >= text.length) return;
+    const timer = setTimeout(() => {
+      setVisible((prev) => Math.min(prev + 2, text.length));
+    }, speed);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [visible, text, speed]);
+
+  return <Text color={color}>{text.slice(0, visible)}</Text>;
+}
+
+export function PollText({
+  text,
+  color,
+  animate,
+}: {
+  text: string;
+  color: string;
+  animate: boolean;
+}): React.ReactElement {
+  if (animate) {
+    return <TypewriterText text={text} color={color} />;
+  }
+  return <Text color={color}>{text}</Text>;
+}

package/templates/edit-section.ts

@@ -0,0 +1,64 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export function replaceSection(fileContent: string, heading: string, newContent: string): string {
+  const lines = fileContent.split('\n');
+  const headingLine = `## ${heading}`;
+
+  let startIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === headingLine) {
+      startIdx = i;
+      break;
+    }
+  }
+
+  if (startIdx === -1) {
+    throw new Error(`Section "## ${heading}" not found in file.`);
+  }
+
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith('## ') || trimmed.startsWith('# ')) {
+      endIdx = i;
+      break;
+    }
+  }
+
+  const before = lines.slice(0, startIdx + 1);
+  const after = lines.slice(endIdx);
+  const trimmedContent = newContent.trim();
+  const newSection = ['', ...trimmedContent.split('\n'), ''];
+
+  const result = [...before, ...newSection, ...after].join('\n');
+  return result;
+}
+
+export const editSectionTool = tool({
+  description: 'Edit a section of SOUL.md or STRATEGY.md. Only call AFTER user confirms.',
+  inputSchema: z.object({
+    file: z.enum(['SOUL.md', 'STRATEGY.md']),
+    section: z.string().describe('Exact ## heading name, e.g. "Personality", "Conviction Style"'),
+    content: z.string().describe('New content for the section (without the ## heading line)'),
+  }),
+  execute: async ({ file, section, content }) => {
+    const filePath = path.join(process.cwd(), file);
+    let fileContent: string;
+    try {
+      fileContent = await fs.readFile(filePath, 'utf-8');
+    } catch {
+      return `Error: ${file} not found in current directory.`;
+    }
+    try {
+      const updated = replaceSection(fileContent, section, content);
+      await fs.writeFile(filePath, updated, 'utf-8');
+      return `Updated "${section}" section in ${file}.`;
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error: ${message}`;
+    }
+  },
+});

package/templates/fetch-rules.ts

@@ -0,0 +1,23 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const RULES_URL = 'https://hive.z3n.dev/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}`;
+    }
+  },
+});