@johpaz/hive-core 0.1.1

package/src/gateway/slash-commands.ts

@@ -0,0 +1,176 @@
+import type { ServerWebSocket } from "bun";
+import { sessionManager } from "./session.ts";
+import { laneQueue } from "./lane-queue.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface InboundMessage {
+  type: "message" | "command" | "ping";
+  sessionId: string;
+  content?: string;
+  command?: string;
+  args?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface OutboundMessage {
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result";
+  sessionId: string;
+  content?: string;
+  chunk?: string;
+  isLast?: boolean;
+  status?: {
+    state: string;
+    model?: string;
+    tokens?: number;
+  };
+  error?: string;
+  result?: unknown;
+}
+
+export interface SlashCommand {
+  name: string;
+  description: string;
+  handler: (sessionId: string, args: string[], ws: ServerWebSocket<unknown>) => Promise<unknown>;
+}
+
+const slashCommands = new Map<string, SlashCommand>();
+
+export function registerSlashCommand(command: SlashCommand): void {
+  slashCommands.set(command.name, command);
+}
+
+export function isSlashCommand(content: string): boolean {
+  return content.startsWith("/") && content.length > 1;
+}
+
+export function parseSlashCommand(content: string): { name: string; args: string[] } | null {
+  if (!isSlashCommand(content)) return null;
+
+  const parts = content.slice(1).split(/\s+/);
+  const name = parts[0]?.toLowerCase();
+  if (!name) return null;
+
+  return {
+    name,
+    args: parts.slice(1),
+  };
+}
+
+export async function executeSlashCommand(
+  sessionId: string,
+  content: string,
+  ws: ServerWebSocket<unknown>
+): Promise<OutboundMessage> {
+  const parsed = parseSlashCommand(content);
+  if (!parsed) {
+    return {
+      type: "error",
+      sessionId,
+      error: "Invalid slash command format",
+    };
+  }
+
+  const command = slashCommands.get(parsed.name);
+  if (!command) {
+    return {
+      type: "error",
+      sessionId,
+      error: `Unknown command: /${parsed.name}`,
+    };
+  }
+
+  logger.info(`Executing slash command: /${parsed.name}`, { sessionId, args: parsed.args });
+
+  try {
+    const result = await command.handler(sessionId, parsed.args, ws);
+    return {
+      type: "command_result",
+      sessionId,
+      result,
+    };
+  } catch (error) {
+    logger.error(`Slash command failed: /${parsed.name}`, { error: (error as Error).message });
+    return {
+      type: "error",
+      sessionId,
+      error: (error as Error).message,
+    };
+  }
+}
+
+registerSlashCommand({
+  name: "stop",
+  description: "Stop the current task",
+  handler: async (sessionId) => {
+    const cancelled = laneQueue.cancel(sessionId);
+    return {
+      success: cancelled,
+      message: cancelled ? "Task stopped" : "No task running",
+    };
+  },
+});
+
+registerSlashCommand({
+  name: "status",
+  description: "Show session status",
+  handler: async (sessionId) => {
+    const session = sessionManager.get(sessionId);
+    const queueStatus = laneQueue.getStatus(sessionId);
+    
+    return {
+      sessionId,
+      createdAt: session?.createdAt,
+      messageCount: session?.messageCount,
+      queueLength: queueStatus.queueLength,
+      isProcessing: queueStatus.running !== undefined,
+    };
+  },
+});
+
+registerSlashCommand({
+  name: "new",
+  description: "Start a new session",
+  handler: async (sessionId) => {
+    sessionManager.delete(sessionId);
+    return { success: true, message: "Session reset" };
+  },
+});
+
+registerSlashCommand({
+  name: "compact",
+  description: "Force context compaction",
+  handler: async (sessionId) => {
+    logger.info(`Compaction requested for session: ${sessionId}`);
+    return { success: true, message: "Compaction triggered" };
+  },
+});
+
+registerSlashCommand({
+  name: "reset",
+  description: "Reset the current context",
+  handler: async (sessionId) => {
+    logger.info(`Context reset requested for session: ${sessionId}`);
+    return { success: true, message: "Context reset" };
+  },
+});
+
+registerSlashCommand({
+  name: "model",
+  description: "Switch model for this session",
+  handler: async (_sessionId, args) => {
+    const modelName = args[0];
+    if (!modelName) {
+      return { success: false, message: "Usage: /model <model-name>" };
+    }
+    return { success: true, message: `Model switched to: ${modelName}` };
+  },
+});
+
+registerSlashCommand({
+  name: "help",
+  description: "Show available commands",
+  handler: async () => {
+    const commands = Array.from(slashCommands.values()).map((c) => `/${c.name} - ${c.description}`);
+    return { commands };
+  },
+});

package/src/heartbeat/index.ts

@@ -0,0 +1,157 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface HealthStatus {
+  status: "healthy" | "degraded" | "unhealthy";
+  checks: Record<string, {
+    status: "ok" | "warning" | "error";
+    message?: string;
+    latency?: number;
+  }>;
+  uptime: number;
+  lastCheck: Date;
+}
+
+export interface HeartbeatOptions {
+  intervalMs?: number;
+  onHealthChange?: (status: HealthStatus) => void;
+}
+
+type HealthCheck = () => Promise<{
+  status: "ok" | "warning" | "error";
+  message?: string;
+  latency?: number;
+}>;
+
+export class Heartbeat {
+  private intervalMs: number;
+  private checks: Map<string, HealthCheck> = new Map();
+  private intervalId: Timer | null = null;
+  private startTime: Date;
+  private lastStatus: HealthStatus | null = null;
+  private onHealthChange?: (status: HealthStatus) => void;
+  private log = logger.child("heartbeat");
+
+  constructor(_config: Config, options: HeartbeatOptions = {}) {
+    this.intervalMs = options.intervalMs ?? 30000;
+    this.onHealthChange = options.onHealthChange;
+    this.startTime = new Date();
+  }
+
+  registerCheck(name: string, check: HealthCheck): void {
+    this.checks.set(name, check);
+    this.log.debug(`Registered health check: ${name}`);
+  }
+
+  removeCheck(name: string): boolean {
+    return this.checks.delete(name);
+  }
+
+  async runChecks(): Promise<HealthStatus> {
+    const checks: HealthStatus["checks"] = {};
+    let overallStatus: "healthy" | "degraded" | "unhealthy" = "healthy";
+
+    for (const [name, check] of this.checks) {
+      try {
+        const start = Date.now();
+        const result = await check();
+        const latency = Date.now() - start;
+
+        checks[name] = {
+          status: result.status,
+          message: result.message,
+          latency: result.latency ?? latency,
+        };
+
+        if (result.status === "warning" && overallStatus === "healthy") {
+          overallStatus = "degraded";
+        } else if (result.status === "error") {
+          overallStatus = "unhealthy";
+        }
+      } catch (error) {
+        checks[name] = {
+          status: "error",
+          message: (error as Error).message,
+        };
+        overallStatus = "unhealthy";
+      }
+    }
+
+    const status: HealthStatus = {
+      status: overallStatus,
+      checks,
+      uptime: Date.now() - this.startTime.getTime(),
+      lastCheck: new Date(),
+    };
+
+    const prevStatus = this.lastStatus?.status;
+    if (prevStatus && prevStatus !== overallStatus) {
+      this.log.info(`Health status changed: ${prevStatus} -> ${overallStatus}`);
+      this.onHealthChange?.(status);
+    }
+
+    this.lastStatus = status;
+    return status;
+  }
+
+  start(): void {
+    if (this.intervalId) {
+      this.log.warn("Heartbeat already running");
+      return;
+    }
+
+    this.runChecks();
+
+    this.intervalId = setInterval(async () => {
+      await this.runChecks();
+    }, this.intervalMs);
+
+    this.log.info(`Heartbeat started (interval: ${this.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.log.info("Heartbeat stopped");
+    }
+  }
+
+  getStatus(): HealthStatus | null {
+    return this.lastStatus;
+  }
+
+  isRunning(): boolean {
+    return this.intervalId !== null;
+  }
+}
+
+export function createHeartbeat(config: Config, options?: HeartbeatOptions): Heartbeat {
+  const heartbeat = new Heartbeat(config, options);
+
+  heartbeat.registerCheck("memory", async () => {
+    const memUsage = process.memoryUsage();
+    const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+    const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
+    const ratio = memUsage.heapUsed / memUsage.heapTotal;
+
+    if (ratio > 0.9) {
+      return {
+        status: "error",
+        message: `Memory critically high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    } else if (ratio > 0.75) {
+      return {
+        status: "warning",
+        message: `Memory usage high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    }
+
+    return {
+      status: "ok",
+      message: `${heapUsedMB}/${heapTotalMB}MB used`,
+    };
+  });
+
+  return heartbeat;
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from "./gateway/index.ts";
+export * from "./gateway/server.ts";
+export * from "./agent/index.ts";
+export * from "./agent/ethics.ts";
+export * from "./agent/context.ts";
+export * from "./agent/soul.ts";
+export * from "./agent/user.ts";
+export * from "./channels/index.ts";
+export * from "./channels/manager.ts";
+export * from "./config/loader.ts";
+export * from "./utils/logger.ts";
+export * from "./utils/crypto.ts";
+export * from "./utils/retry.ts";
+export * from "./security/index.ts";
+export * from "./heartbeat/index.ts";
+export * from "./tools/registry.ts";
+export * from "./multi-agent/manager.ts";
+export * from "./multi-agent/bindings.ts";
+export * from "./multi-agent/sandbox.ts";
+export * from "./multi-agent/subagents.ts";
+export * from "./memory/notes.ts";

package/src/memory/index.ts

@@ -0,0 +1 @@
+export * from "./notes.ts";

package/src/memory/notes.ts

@@ -0,0 +1,170 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface Note {
+  title: string;
+  content: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class MemoryStore {
+  private notesDir: string;
+  private log = logger.child("memory");
+
+  constructor(config: Config) {
+    this.notesDir = this.expandPath(
+      config.memory?.notesDir ?? "~/.hive/agents/main/workspace/memory"
+    );
+    this.ensureDir();
+  }
+
+  private expandPath(p: string): string {
+    if (p.startsWith("~")) {
+      return path.join(process.env.HOME ?? "", p.slice(1));
+    }
+    return p;
+  }
+
+  private ensureDir(): void {
+    if (!fs.existsSync(this.notesDir)) {
+      fs.mkdirSync(this.notesDir, { recursive: true });
+    }
+  }
+
+  private getNotePath(title: string): string {
+    const safeTitle = title.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
+    return path.join(this.notesDir, `${safeTitle}.md`);
+  }
+
+  write(title: string, content: string): Note {
+    const notePath = this.getNotePath(title);
+    const now = new Date();
+    
+    let note: Note;
+    
+    if (fs.existsSync(notePath)) {
+      const existing = fs.readFileSync(notePath, "utf-8");
+      const lines = existing.split("\n");
+      const createdAtLine = lines.find((l) => l.startsWith("created:"));
+      const createdAt = createdAtLine
+        ? new Date(createdAtLine.replace("created:", "").trim())
+        : now;
+      
+      note = {
+        title,
+        content,
+        createdAt,
+        updatedAt: now,
+      };
+    } else {
+      note = {
+        title,
+        content,
+        createdAt: now,
+        updatedAt: now,
+      };
+    }
+
+    const frontmatter = `---
+title: ${title}
+created: ${note.createdAt.toISOString()}
+updated: ${note.updatedAt.toISOString()}
+---
+
+${content}`;
+
+    fs.writeFileSync(notePath, frontmatter, "utf-8");
+    this.log.debug(`Wrote note: ${title}`);
+    
+    return note;
+  }
+
+  read(title: string): Note | null {
+    const notePath = this.getNotePath(title);
+    
+    if (!fs.existsSync(notePath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(notePath, "utf-8");
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    
+    if (!match) {
+      return {
+        title,
+        content,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+    }
+
+    const frontmatter = match[1]!;
+    const body = match[2]!.trim();
+    
+    const titleMatch = frontmatter.match(/title:\s*(.+)/);
+    const createdMatch = frontmatter.match(/created:\s*(.+)/);
+    const updatedMatch = frontmatter.match(/updated:\s*(.+)/);
+
+    return {
+      title: titleMatch?.[1]?.trim() ?? title,
+      content: body,
+      createdAt: createdMatch ? new Date(createdMatch[1]!) : new Date(),
+      updatedAt: updatedMatch ? new Date(updatedMatch[1]!) : new Date(),
+    };
+  }
+
+  list(): Array<{ title: string; path: string }> {
+    if (!fs.existsSync(this.notesDir)) {
+      return [];
+    }
+
+    const files = fs.readdirSync(this.notesDir).filter((f) => f.endsWith(".md"));
+    
+    return files.map((file) => {
+      const filePath = path.join(this.notesDir, file);
+      const content = fs.readFileSync(filePath, "utf-8");
+      const titleMatch = content.match(/title:\s*(.+)/);
+      
+      return {
+        title: titleMatch?.[1]?.trim() ?? file.replace(".md", ""),
+        path: filePath,
+      };
+    });
+  }
+
+  delete(title: string): boolean {
+    const notePath = this.getNotePath(title);
+    
+    if (fs.existsSync(notePath)) {
+      fs.unlinkSync(notePath);
+      this.log.debug(`Deleted note: ${title}`);
+      return true;
+    }
+    
+    return false;
+  }
+
+  search(query: string): Note[] {
+    const results: Note[] = [];
+    const lowerQuery = query.toLowerCase();
+    
+    for (const { title } of this.list()) {
+      const note = this.read(title);
+      if (note && (
+        note.title.toLowerCase().includes(lowerQuery) ||
+        note.content.toLowerCase().includes(lowerQuery)
+      )) {
+        results.push(note);
+      }
+    }
+    
+    return results;
+  }
+}
+
+export function createMemoryStore(config: Config): MemoryStore {
+  return new MemoryStore(config);
+}

package/src/multi-agent/bindings.ts

@@ -0,0 +1,171 @@
+import type { Config, Binding } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface RoutingContext {
+  channel: string;
+  accountId?: string;
+  peerId?: string;
+  peerKind?: "direct" | "group";
+  guildId?: string;
+  teamId?: string;
+  roles?: string[];
+}
+
+export class BindingRouter {
+  private config: Config;
+  private bindings: Binding[];
+  private log = logger.child("bindings");
+
+  constructor(config: Config) {
+    this.config = config;
+    this.bindings = config.bindings ?? [];
+  }
+
+  resolve(ctx: RoutingContext): string {
+    if (this.bindings.length === 0) {
+      return this.getDefaultAgentId();
+    }
+
+    const scoredBindings: Array<{ binding: Binding; score: number }> = [];
+
+    for (const binding of this.bindings) {
+      const score = this.calculateScore(binding, ctx);
+      if (score > 0) {
+        scoredBindings.push({ binding, score });
+      }
+    }
+
+    if (scoredBindings.length === 0) {
+      return this.getDefaultAgentId();
+    }
+
+    scoredBindings.sort((a, b) => b.score - a.score);
+
+    const best = scoredBindings[0];
+    this.log.debug(`Routing to agent: ${best?.binding.agentId}`, { 
+      score: best?.score,
+      channel: ctx.channel 
+    });
+
+    return best?.binding.agentId ?? this.getDefaultAgentId();
+  }
+
+  private calculateScore(binding: Binding, ctx: RoutingContext): number {
+    const match = binding.match;
+    let score = 0;
+
+    if (match.peer?.id && match.peer?.kind) {
+      if (ctx.peerId === match.peer.id && ctx.peerKind === match.peer.kind) {
+        score += 1000;
+      } else {
+        return 0;
+      }
+    } else if (match.peer?.id) {
+      if (ctx.peerId === match.peer.id) {
+        score += 900;
+      } else {
+        return 0;
+      }
+    } else if (match.peer?.kind) {
+      if (ctx.peerKind === match.peer.kind) {
+        score += 100;
+      } else {
+        return 0;
+      }
+    }
+
+    if (match.guildId) {
+      if (ctx.guildId === match.guildId) {
+        if (match.roles && match.roles.length > 0) {
+          const hasRole = ctx.roles?.some((r) => match.roles?.includes(r));
+          if (hasRole) {
+            score += 800;
+          } else {
+            return 0;
+          }
+        } else {
+          score += 200;
+        }
+      } else {
+        return 0;
+      }
+    }
+
+    if (match.teamId) {
+      if (ctx.teamId === match.teamId) {
+        score += 300;
+      } else {
+        return 0;
+      }
+    }
+
+    if (match.accountId) {
+      if (ctx.accountId === match.accountId) {
+        score += 400;
+      } else {
+        return 0;
+      }
+    }
+
+    if (match.channel) {
+      if (ctx.channel === match.channel) {
+        score += 50;
+      } else {
+        return 0;
+      }
+    }
+
+    return score || 1;
+  }
+
+  private getDefaultAgentId(): string {
+    const agents = this.config.agents?.list ?? [];
+    
+    for (const agent of agents) {
+      if (agent.default) {
+        return agent.id;
+      }
+    }
+
+    return "main";
+  }
+
+  addBinding(binding: Binding): void {
+    this.bindings.push(binding);
+    this.log.info(`Added binding: ${binding.agentId}`, { match: binding.match });
+  }
+
+  removeBinding(agentId: string, match?: Partial<Binding["match"]>): number {
+    const initialLength = this.bindings.length;
+    
+    this.bindings = this.bindings.filter((b) => {
+      if (b.agentId !== agentId) return true;
+      if (!match) return false;
+      
+      for (const [key, value] of Object.entries(match)) {
+        if (JSON.stringify((b.match as any)[key]) !== JSON.stringify(value)) {
+          return true;
+        }
+      }
+      return false;
+    });
+
+    const removed = initialLength - this.bindings.length;
+    if (removed > 0) {
+      this.log.info(`Removed ${removed} binding(s) for agent: ${agentId}`);
+    }
+    return removed;
+  }
+
+  listBindings(): Binding[] {
+    return [...this.bindings];
+  }
+
+  getBindingsForAgent(agentId: string): Binding[] {
+    return this.bindings.filter((b) => b.agentId === agentId);
+  }
+}
+
+export function createBindingRouter(config: Config): BindingRouter {
+  return new BindingRouter(config);
+}

package/src/multi-agent/index.ts

@@ -0,0 +1,4 @@
+export * from "./manager.ts";
+export * from "./bindings.ts";
+export * from "./sandbox.ts";
+export * from "./subagents.ts";