@johpaz/hive-core 1.0.7 → 1.0.10

package/src/state/store.ts

@@ -0,0 +1,310 @@
+export interface SessionState {
+  id: string;
+  agentId: string;
+  channel: string;
+  userId: string;
+  createdAt: number;
+  lastActivityAt: number;
+  messageCount: number;
+  status: "active" | "idle" | "closed";
+}
+
+export interface AgentState {
+  id: string;
+  name: string;
+  status: "ready" | "busy" | "error";
+  currentSessionId?: string;
+  lastError?: string;
+}
+
+export interface ChannelState {
+  name: string;
+  accountId: string;
+  status: "connected" | "disconnected" | "error";
+  lastActivity?: number;
+  error?: string;
+}
+
+export interface MetricsState {
+  totalMessages: number;
+  totalSessions: number;
+  totalToolCalls: number;
+  averageResponseTime: number;
+  errors: number;
+  startedAt: number;
+}
+
+export interface HiveState {
+  sessions: Map<string, SessionState>;
+  agents: Map<string, AgentState>;
+  channels: Map<string, ChannelState>;
+  metrics: MetricsState;
+}
+
+export interface StateSnapshot {
+  id: string;
+  timestamp: number;
+  state: HiveState;
+  reason?: string;
+  action?: string;
+  correlationId?: string;
+}
+
+interface StateStoreOptions {
+  maxSnapshots?: number;
+  enableSnapshots?: boolean;
+}
+
+const defaultMetrics: MetricsState = {
+  totalMessages: 0,
+  totalSessions: 0,
+  totalToolCalls: 0,
+  averageResponseTime: 0,
+  errors: 0,
+  startedAt: Date.now(),
+};
+
+export class StateStore {
+  private state: HiveState;
+  private snapshots: StateSnapshot[] = [];
+  private readonly maxSnapshots: number;
+  private readonly enableSnapshots: boolean;
+  private listeners: Set<(state: Readonly<HiveState>) => void> = new Set();
+  private correlationId?: string;
+
+  constructor(options: StateStoreOptions = {}) {
+    this.maxSnapshots = options.maxSnapshots ?? 100;
+    this.enableSnapshots = options.enableSnapshots ?? true;
+    this.state = this.createInitialState();
+  }
+
+  setCorrelationId(id: string): void {
+    this.correlationId = id;
+  }
+
+  getCorrelationId(): string | undefined {
+    return this.correlationId;
+  }
+
+  clearCorrelationId(): void {
+    this.correlationId = undefined;
+  }
+
+  private createInitialState(): HiveState {
+    return {
+      sessions: new Map(),
+      agents: new Map(),
+      channels: new Map(),
+      metrics: { ...defaultMetrics },
+    };
+  }
+
+  getState(): Readonly<HiveState> {
+    return this.state;
+  }
+
+  update(updater: (draft: HiveState) => void, reason?: string): void {
+    const newState = this.cloneState(this.state);
+    updater(newState);
+
+    if (this.enableSnapshots) {
+      this.saveSnapshot(newState, reason);
+    }
+
+    this.state = newState;
+    this.notifyListeners();
+  }
+
+  private cloneState(state: HiveState): HiveState {
+    return {
+      sessions: new Map(state.sessions),
+      agents: new Map(state.agents),
+      channels: new Map(state.channels),
+      metrics: { ...state.metrics },
+    };
+  }
+
+  private saveSnapshot(state: HiveState, reason?: string): void {
+    const snapshot: StateSnapshot = {
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+      state: this.cloneState(state),
+      reason,
+      action: reason,
+      correlationId: this.correlationId,
+    };
+
+    this.snapshots.push(snapshot);
+
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots.shift();
+    }
+  }
+
+  getSnapshotAt(timestamp: number): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.timestamp >= timestamp);
+  }
+
+  getSnapshotById(id: string): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.id === id);
+  }
+
+  getAllSnapshots(): StateSnapshot[] {
+    return [...this.snapshots];
+  }
+
+  getRecentSnapshots(count: number = 10): StateSnapshot[] {
+    return this.snapshots.slice(-count);
+  }
+
+  subscribe(listener: (state: Readonly<HiveState>) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notifyListeners(): void {
+    const state = this.getState();
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[StateStore] Listener error:", error);
+      }
+    }
+  }
+
+  createSession(session: Omit<SessionState, "createdAt" | "lastActivityAt" | "messageCount" | "status">): SessionState {
+    const newSession: SessionState = {
+      ...session,
+      createdAt: Date.now(),
+      lastActivityAt: Date.now(),
+      messageCount: 0,
+      status: "active",
+    };
+
+    this.update((state) => {
+      state.sessions.set(session.id, newSession);
+      state.metrics.totalSessions++;
+    }, `Session created: ${session.id}`);
+
+    return newSession;
+  }
+
+  updateSession(sessionId: string, updates: Partial<SessionState>): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, ...updates });
+      }
+    }, `Session updated: ${sessionId}`);
+  }
+
+  closeSession(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, status: "closed" });
+      }
+    }, `Session closed: ${sessionId}`);
+  }
+
+  incrementMessageCount(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        session.messageCount++;
+        session.lastActivityAt = Date.now();
+        state.sessions.set(sessionId, session);
+        state.metrics.totalMessages++;
+      }
+    });
+  }
+
+  registerAgent(agent: Omit<AgentState, "status">): void {
+    this.update((state) => {
+      state.agents.set(agent.id, { ...agent, status: "ready" });
+    }, `Agent registered: ${agent.id}`);
+  }
+
+  updateAgent(agentId: string, updates: Partial<AgentState>): void {
+    this.update((state) => {
+      const agent = state.agents.get(agentId);
+      if (agent) {
+        state.agents.set(agentId, { ...agent, ...updates });
+      }
+    }, `Agent updated: ${agentId}`);
+  }
+
+  updateChannel(channelName: string, accountId: string, updates: Partial<ChannelState>): void {
+    this.update((state) => {
+      const key = `${channelName}:${accountId}`;
+      const channel = state.channels.get(key);
+      if (channel) {
+        state.channels.set(key, { ...channel, ...updates });
+      } else {
+        state.channels.set(key, {
+          name: channelName,
+          accountId,
+          status: "disconnected",
+          ...updates,
+        });
+      }
+    }, `Channel updated: ${channelName}:${accountId}`);
+  }
+
+  recordToolCall(duration: number, success: boolean): void {
+    this.update((state) => {
+      state.metrics.totalToolCalls++;
+      if (!success) {
+        state.metrics.errors++;
+      }
+      const total = state.metrics.totalToolCalls;
+      const prevAvg = state.metrics.averageResponseTime;
+      state.metrics.averageResponseTime = prevAvg + (duration - prevAvg) / total;
+    });
+  }
+
+  reset(): void {
+    this.state = this.createInitialState();
+    this.snapshots = [];
+    this.saveSnapshot(this.state, "Store reset");
+  }
+
+  exportState(): string {
+    const exportable = {
+      sessions: Object.fromEntries(this.state.sessions),
+      agents: Object.fromEntries(this.state.agents),
+      channels: Object.fromEntries(this.state.channels),
+      metrics: this.state.metrics,
+    };
+    return JSON.stringify(exportable, null, 2);
+  }
+
+  export(): string {
+    return this.exportState();
+  }
+
+  getStats(): {
+    sessionsCount: number;
+    activeSessions: number;
+    agentsCount: number;
+    channelsCount: number;
+    snapshotsCount: number;
+    uptime: number;
+  } {
+    const activeSessions = Array.from(this.state.sessions.values()).filter(
+      (s) => s.status === "active"
+    ).length;
+
+    return {
+      sessionsCount: this.state.sessions.size,
+      activeSessions,
+      agentsCount: this.state.agents.size,
+      channelsCount: this.state.channels.size,
+      snapshotsCount: this.snapshots.length,
+      uptime: Date.now() - this.state.metrics.startedAt,
+    };
+  }
+}
+
+export const stateStore = new StateStore();

package/src/storage/sqlite.ts

@@ -1,7 +1,7 @@
 import { Database } from "bun:sqlite";
 import { logger } from "../utils/logger.ts";
 import * as path from "node:path";
-import * as fs from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 
 export interface ChatMessageRow {
     id: string;
@@ -30,8 +30,8 @@ export class DatabaseService {
 
         // Ensure directory exists
         const dir = path.dirname(targetPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
         }
 
         this.db = new Database(targetPath, { create: true });

package/src/tools/cron.ts

@@ -13,11 +13,51 @@ export interface CronJob {
   createdAt: Date;
 }
 
-export function createCronTools(_config: Config): Tool[] {
+function matchCron(expr: string, date: Date): boolean {
+  try {
+    const parts = expr.split(/\s+/);
+    if (parts.length !== 5) return false;
+    const [min, hour, dom, month, dow] = parts;
+    const match = (val: number, p: string) => {
+      if (p === "*") return true;
+      if (p.startsWith("*/")) return val % parseInt(p.slice(2), 10) === 0;
+      return parseInt(p, 10) === val;
+    };
+    return match(date.getMinutes(), min) &&
+      match(date.getHours(), hour) &&
+      match(date.getDate(), dom) &&
+      match(date.getMonth() + 1, month) &&
+      match(date.getDay(), dow);
+  } catch {
+    return false;
+  }
+}
+
+let cronInterval: ReturnType<typeof setInterval> | null = null;
+
+export function createCronTools(_config: Config, onTrigger?: (sessionId: string, task: string) => void): Tool[] {
   const log = logger.child("cron");
   const jobs: Map<string, CronJob> = new Map();
   let jobIdCounter = 0;
 
+  if (cronInterval) clearInterval(cronInterval);
+  cronInterval = setInterval(() => {
+    const now = new Date();
+    for (const job of jobs.values()) {
+      if (!job.enabled) continue;
+
+      const lastRunMin = job.lastRun ? Math.floor(job.lastRun.getTime() / 60000) : 0;
+      const currentMin = Math.floor(now.getTime() / 60000);
+      if (lastRunMin === currentMin) continue;
+
+      if (matchCron(job.expression, now)) {
+        job.lastRun = now;
+        log.info(`Cron triggered: ${job.id} for task: ${job.task}`);
+        if (onTrigger) onTrigger(job.sessionId, job.task);
+      }
+    }
+  }, 30000);
+
   const cronAdd: Tool = {
     name: "cron_add",
     description: "Add a scheduled task",
@@ -45,7 +85,7 @@ export function createCronTools(_config: Config): Tool[] {
       const sessionId = (params.sessionId as string) ?? "agent:main:main";
 
       const id = `cron-${++jobIdCounter}`;
-      
+
       const job: CronJob = {
         id,
         sessionId,

package/src/tools/dynamic-registry.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { DynamicToolRegistry } from "../tools/dynamic-registry.ts";
+
+describe("DynamicToolRegistry", () => {
+  let registry: DynamicToolRegistry;
+
+  beforeEach(() => {
+    registry = new DynamicToolRegistry();
+  });
+
+  it("should register a tool", () => {
+    registry.register({
+      name: "calculator_add",
+      description: "Sumar dos números",
+      parameters: {
+        a: { type: "number", description: "Primer número", required: true },
+        b: { type: "number", description: "Segundo número", required: true },
+      },
+      execute: async ({ a, b }) => (a as number) + (b as number),
+    });
+
+    const tool = registry.get("calculator_add");
+    expect(tool).toBeDefined();
+    expect(tool?.description).toBe("Sumar dos números");
+  });
+
+  it("should validate parameters on execution", async () => {
+    registry.register({
+      name: "validated_tool",
+      description: "A tool with validation",
+      parameters: {
+        value: { type: "number", required: true },
+      },
+      execute: async ({ value }) => value,
+    });
+
+    const tool = registry.get("validated_tool");
+    expect(tool).toBeDefined();
+
+    await expect(tool!.execute({ value: 42 })).resolves.toBe(42);
+
+    await expect(tool!.execute({ value: "invalid" })).rejects.toThrow();
+  });
+
+  it("should unregister a tool", () => {
+    registry.register({
+      name: "temp_tool",
+      description: "Temporary",
+      parameters: {},
+      execute: async () => null,
+    });
+
+    expect(registry.has("temp_tool")).toBe(true);
+
+    registry.unregister("temp_tool");
+
+    expect(registry.has("temp_tool")).toBe(false);
+  });
+
+  it("should list all tools", () => {
+    registry.register({
+      name: "tool1",
+      description: "Tool 1",
+      parameters: {},
+      execute: async () => null,
+    });
+    registry.register({
+      name: "tool2",
+      description: "Tool 2",
+      parameters: {},
+      execute: async () => null,
+    });
+
+    const tools = registry.list();
+    expect(tools.length).toBe(2);
+    expect(tools.map((t) => t.name)).toContain("tool1");
+    expect(tools.map((t) => t.name)).toContain("tool2");
+  });
+
+  it("should list tool names", () => {
+    registry.register({
+      name: "named_tool",
+      description: "Named tool",
+      parameters: {},
+      execute: async () => null,
+    });
+
+    const names = registry.listNames();
+    expect(names).toContain("named_tool");
+  });
+
+  it("should handle optional parameters", async () => {
+    registry.register({
+      name: "optional_params",
+      description: "Tool with optional params",
+      parameters: {
+        required: { type: "string", required: true },
+        optional: { type: "string", required: false },
+      },
+      execute: async (args) => args,
+    });
+
+    const tool = registry.get("optional_params");
+
+    await expect(tool!.execute({ required: "test" })).resolves.toEqual({
+      required: "test",
+    });
+
+    await expect(
+      tool!.execute({ required: "test", optional: "value" })
+    ).resolves.toEqual({ required: "test", optional: "value" });
+  });
+
+  it("should handle enum parameters", async () => {
+    registry.register({
+      name: "enum_tool",
+      description: "Tool with enum",
+      parameters: {
+        status: {
+          type: "string",
+          enum: ["active", "inactive", "pending"],
+          required: true,
+        },
+      },
+      execute: async ({ status }) => status,
+    });
+
+    const tool = registry.get("enum_tool");
+
+    await expect(tool!.execute({ status: "active" })).resolves.toBe("active");
+
+    await expect(tool!.execute({ status: "invalid" })).rejects.toThrow();
+  });
+
+  it("should handle array parameters", async () => {
+    registry.register({
+      name: "array_tool",
+      description: "Tool with array",
+      parameters: {
+        items: {
+          type: "array",
+          items: { type: "string" },
+          required: true,
+        },
+      },
+      execute: async ({ items }) => items,
+    });
+
+    const tool = registry.get("array_tool");
+
+    await expect(tool!.execute({ items: ["a", "b", "c"] })).resolves.toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  it("should track stats", () => {
+    registry.register({
+      name: "stats_tool",
+      description: "For stats",
+      parameters: {},
+      execute: async () => null,
+    });
+
+    const stats = registry.getStats();
+    expect(stats.total).toBe(1);
+    expect(stats.byPlugin["core"]).toBe(1);
+  });
+
+  it("should convert to Tool interface", () => {
+    registry.register({
+      name: "convert_tool",
+      description: "For conversion",
+      parameters: {
+        input: { type: "string", description: "Input value" },
+      },
+      execute: async () => "result",
+    });
+
+    const tool = registry.toToolInterface("convert_tool");
+    expect(tool).toBeDefined();
+    expect(tool?.name).toBe("convert_tool");
+    expect(tool?.parameters.type).toBe("object");
+    expect(tool?.parameters.properties).toHaveProperty("input");
+  });
+
+  it("should register tools from plugins", () => {
+    registry.register(
+      {
+        name: "plugin_tool",
+        description: "From plugin",
+        parameters: {},
+        execute: async () => null,
+      },
+      "test-plugin"
+    );
+
+    const tool = registry.get("plugin_tool");
+    expect(tool?.pluginName).toBe("test-plugin");
+
+    const pluginTools = registry.listByPlugin("test-plugin");
+    expect(pluginTools.length).toBe(1);
+  });
+
+  it("should clear all tools", () => {
+    registry.register({
+      name: "clear1",
+      description: "To clear",
+      parameters: {},
+      execute: async () => null,
+    });
+    registry.register({
+      name: "clear2",
+      description: "To clear",
+      parameters: {},
+      execute: async () => null,
+    });
+
+    expect(registry.list().length).toBe(2);
+
+    registry.clear();
+
+    expect(registry.list().length).toBe(0);
+  });
+});