@johpaz/hive-core 0.1.1

package/src/multi-agent/manager.ts

@@ -0,0 +1,182 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Config, AgentEntry } from "../config/loader.ts";
+import { Agent } from "../agent/index.ts";
+import { ToolRegistry } from "../tools/registry.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface AgentInstance {
+  id: string;
+  agent: Agent;
+  toolRegistry: ToolRegistry;
+  workspacePath: string;
+  isDefault: boolean;
+}
+
+export class AgentManager {
+  private config: Config;
+  private agents: Map<string, AgentInstance> = new Map();
+  private log = logger.child("agent-manager");
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  async initialize(): Promise<void> {
+    const agentList = this.config.agents?.list ?? [];
+    
+    if (agentList.length === 0) {
+      await this.createDefaultAgent();
+      return;
+    }
+
+    for (const entry of agentList) {
+      await this.createAgent(entry);
+    }
+
+    this.log.info(`Initialized ${this.agents.size} agent(s)`);
+  }
+
+  private async createDefaultAgent(): Promise<void> {
+    const defaultWorkspace = this.expandPath(
+      this.config.agent?.baseDir 
+        ? `${this.config.agent.baseDir}/main/workspace`
+        : "~/.hive/agents/main/workspace"
+    );
+
+    await this.createAgent({
+      id: "main",
+      default: true,
+      workspace: defaultWorkspace,
+    });
+  }
+
+  private async createAgent(entry: AgentEntry): Promise<void> {
+    const workspacePath = this.expandPath(entry.workspace);
+    
+    this.ensureWorkspace(workspacePath);
+
+    const agent = new Agent({
+      agentId: entry.id,
+      config: this.config,
+      workspacePath,
+    });
+
+    await agent.initialize();
+
+    const toolRegistry = new ToolRegistry(this.config);
+
+    const instance: AgentInstance = {
+      id: entry.id,
+      agent,
+      toolRegistry,
+      workspacePath,
+      isDefault: entry.default ?? false,
+    };
+
+    this.agents.set(entry.id, instance);
+    this.log.info(`Created agent: ${entry.id}`, { workspace: workspacePath });
+  }
+
+  private expandPath(p: string): string {
+    if (p.startsWith("~")) {
+      return path.join(process.env.HOME ?? "", p.slice(1));
+    }
+    return p;
+  }
+
+  private ensureWorkspace(workspacePath: string): void {
+    const dirs = [
+      workspacePath,
+      path.join(workspacePath, "skills"),
+      path.join(workspacePath, "memory"),
+    ];
+
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    const soulPath = path.join(workspacePath, "SOUL.md");
+    if (!fs.existsSync(soulPath)) {
+      fs.writeFileSync(soulPath, `# Agent Identity\n\nThis is agent ${path.basename(workspacePath)}.\n`);
+    }
+
+    const userPath = path.join(workspacePath, "USER.md");
+    if (!fs.existsSync(userPath)) {
+      fs.writeFileSync(userPath, `# User Profile\n\nName: User\nLanguage: English\n`);
+    }
+  }
+
+  getAgent(agentId: string): AgentInstance | undefined {
+    return this.agents.get(agentId);
+  }
+
+  getDefaultAgent(): AgentInstance | undefined {
+    for (const agent of this.agents.values()) {
+      if (agent.isDefault) {
+        return agent;
+      }
+    }
+    return this.agents.values().next().value;
+  }
+
+  listAgents(): Array<{ id: string; isDefault: boolean; workspace: string }> {
+    return Array.from(this.agents.values()).map((a) => ({
+      id: a.id,
+      isDefault: a.isDefault,
+      workspace: a.workspacePath,
+    }));
+  }
+
+  hasAgent(agentId: string): boolean {
+    return this.agents.has(agentId);
+  }
+
+  async createNewAgent(
+    agentId: string,
+    options: { workspace?: string; isDefault?: boolean } = {}
+  ): Promise<AgentInstance> {
+    if (this.agents.has(agentId)) {
+      throw new Error(`Agent already exists: ${agentId}`);
+    }
+
+    const baseDir = this.config.agent?.baseDir?.replace(/^~/, process.env.HOME ?? "")
+      ?? `${process.env.HOME}/.hive/agents`;
+    
+    const workspace = options.workspace ?? `${baseDir}/${agentId}/workspace`;
+
+    const entry: AgentEntry = {
+      id: agentId,
+      default: options.isDefault ?? false,
+      workspace,
+    };
+
+    await this.createAgent(entry);
+    
+    return this.agents.get(agentId)!;
+  }
+
+  removeAgent(agentId: string): boolean {
+    if (!this.agents.has(agentId)) {
+      return false;
+    }
+
+    if (agentId === "main") {
+      throw new Error("Cannot remove the main agent");
+    }
+
+    this.agents.delete(agentId);
+    this.log.info(`Removed agent: ${agentId}`);
+    return true;
+  }
+
+  getAgentWorkspace(agentId: string): string | undefined {
+    return this.agents.get(agentId)?.workspacePath;
+  }
+}
+
+export function createAgentManager(config: Config): AgentManager {
+  return new AgentManager(config);
+}

package/src/multi-agent/sandbox.ts

@@ -0,0 +1,130 @@
+import type { Config } from "../config/loader.ts";
+
+export type SessionType = "main" | "dm" | "group";
+
+export interface SandboxPolicy {
+  deniedTools: string[];
+  restrictedPaths: string[];
+  maxExecutionTime: number;
+  allowNetwork: boolean;
+}
+
+export class SandboxManager {
+  private config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  getPolicy(sessionType: SessionType): SandboxPolicy {
+    const defaultDenied = ["exec", "write", "edit", "apply_patch"];
+    
+    switch (sessionType) {
+      case "main":
+        return {
+          deniedTools: [],
+          restrictedPaths: [],
+          maxExecutionTime: 60000,
+          allowNetwork: true,
+        };
+
+      case "dm":
+        return {
+          deniedTools: this.config.tools?.sandbox?.dm?.deny ?? defaultDenied,
+          restrictedPaths: [],
+          maxExecutionTime: 30000,
+          allowNetwork: true,
+        };
+
+      case "group":
+        return {
+          deniedTools: this.config.tools?.sandbox?.group?.deny ?? defaultDenied,
+          restrictedPaths: [],
+          maxExecutionTime: 30000,
+          allowNetwork: false,
+        };
+
+      default:
+        return {
+          deniedTools: defaultDenied,
+          restrictedPaths: [],
+          maxExecutionTime: 30000,
+          allowNetwork: false,
+        };
+    }
+  }
+
+  isToolAllowed(toolName: string, sessionType: SessionType): boolean {
+    const policy = this.getPolicy(sessionType);
+    return !policy.deniedTools.includes(toolName);
+  }
+
+  getSessionTypeFromId(sessionId: string): SessionType {
+    const parts = sessionId.split(":");
+    
+    if (parts.length < 4) {
+      return "main";
+    }
+
+    const kind = parts[3];
+    
+    if (kind === "dm") {
+      return "dm";
+    }
+    
+    if (kind === "group") {
+      return "group";
+    }
+
+    return "main";
+  }
+
+  filterAllowedTools(
+    tools: string[],
+    sessionType: SessionType
+  ): string[] {
+    const policy = this.getPolicy(sessionType);
+    return tools.filter((tool) => !policy.deniedTools.includes(tool));
+  }
+
+  validatePath(
+    path: string,
+    sessionType: SessionType,
+    workspacePath: string
+  ): { allowed: boolean; reason?: string } {
+    const policy = this.getPolicy(sessionType);
+
+    if (policy.restrictedPaths.length === 0) {
+      const expandedWorkspace = workspacePath.replace(/^~/, process.env.HOME ?? "");
+      
+      if (!path.startsWith(expandedWorkspace)) {
+        return { 
+          allowed: false, 
+          reason: "Path must be within workspace" 
+        };
+      }
+    }
+
+    return { allowed: true };
+  }
+
+  createSandboxedRegistry(
+    baseRegistry: Map<string, any>,
+    sessionType: SessionType
+  ): Map<string, any> {
+    const policy = this.getPolicy(sessionType);
+    const sandboxed = new Map<string, any>();
+
+    for (const [name, tool] of baseRegistry) {
+      if (!policy.deniedTools.includes(name)) {
+        sandboxed.set(name, tool);
+      }
+    }
+
+    return sandboxed;
+  }
+}
+
+export function createSandboxManager(config: Config): SandboxManager {
+  return new SandboxManager(config);
+}

package/src/multi-agent/subagents.ts

@@ -0,0 +1,302 @@
+import type { Tool, ToolResult } from "../tools/registry.ts";
+import type { Config } from "../config/loader.ts";
+import { Agent } from "../agent/index.ts";
+import { logger } from "../utils/logger.ts";
+import { generateId } from "../utils/crypto.ts";
+
+export interface SubAgentTask {
+  id: string;
+  parentSessionId: string;
+  task: string;
+  delegatedTools: string[];
+  timeout: number;
+  status: "pending" | "running" | "completed" | "failed" | "timeout";
+  result?: unknown;
+  error?: string;
+  startedAt?: Date;
+  completedAt?: Date;
+}
+
+export interface SubAgentOptions {
+  task: string;
+  delegatedTools?: string[];
+  timeout?: number;
+  maxOutputLength?: number;
+}
+
+export class SubAgentManager {
+  private config: Config;
+  private log = logger.child("subagents");
+  private activeTasks: Map<string, SubAgentTask> = new Map();
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  async spawn(
+    parentAgentId: string,
+    parentSessionId: string,
+    options: SubAgentOptions
+  ): Promise<SubAgentTask> {
+    const taskId = `subagent-${generateId()}`;
+    
+    const task: SubAgentTask = {
+      id: taskId,
+      parentSessionId,
+      task: options.task,
+      delegatedTools: options.delegatedTools ?? ["read", "web_search"],
+      timeout: options.timeout ?? 60000,
+      status: "pending",
+    };
+
+    this.activeTasks.set(taskId, task);
+
+    this.log.info(`Spawning sub-agent`, { 
+      taskId, 
+      parentAgentId,
+      delegatedTools: task.delegatedTools 
+    });
+
+    task.status = "running";
+    task.startedAt = new Date();
+
+    try {
+      const result = await this.executeWithTimeout(
+        task,
+        parentAgentId,
+        options.maxOutputLength ?? 5000
+      );
+
+      task.result = result;
+      task.status = "completed";
+      task.completedAt = new Date();
+
+      this.log.info(`Sub-agent completed`, { taskId });
+    } catch (error) {
+      const err = error as Error;
+      
+      if (err.message === "TIMEOUT") {
+        task.status = "timeout";
+        task.error = "Sub-agent exceeded timeout";
+      } else {
+        task.status = "failed";
+        task.error = err.message;
+      }
+      
+      task.completedAt = new Date();
+      this.log.error(`Sub-agent failed`, { taskId, error: task.error });
+    }
+
+    return task;
+  }
+
+  private async executeWithTimeout(
+    task: SubAgentTask,
+    _parentAgentId: string,
+    maxOutputLength: number
+  ): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error("TIMEOUT"));
+      }, task.timeout);
+
+      this.executeTask(task, _parentAgentId, maxOutputLength)
+        .then((result) => {
+          clearTimeout(timeoutId);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        });
+    });
+  }
+
+  private async executeTask(
+    task: SubAgentTask,
+    _parentAgentId: string,
+    maxOutputLength: number
+  ): Promise<unknown> {
+    const agent = new Agent({
+      agentId: `sub-${task.id}`,
+      config: this.config,
+      workspacePath: this.getTempWorkspace(task.id),
+    });
+
+    await agent.initialize();
+
+    const response = await agent.buildPrompt();
+
+    let result = response;
+
+    if (typeof result === "string" && result.length > maxOutputLength) {
+      result = this.truncateOutput(result, maxOutputLength);
+    }
+
+    return result;
+  }
+
+  private getTempWorkspace(taskId: string): string {
+    const baseDir = this.config.agent?.baseDir?.replace(/^~/, process.env.HOME ?? "")
+      ?? `${process.env.HOME}/.hive/agents`;
+    
+    return `${baseDir}/subagents/${taskId}/workspace`;
+  }
+
+  private truncateOutput(output: string, maxLength: number): string {
+    if (output.length <= maxLength) {
+      return output;
+    }
+
+    const half = Math.floor(maxLength / 2);
+    return output.slice(0, half) + 
+      `\n... [truncated ${output.length - maxLength} characters] ...\n` + 
+      output.slice(-half);
+  }
+
+  getTask(taskId: string): SubAgentTask | undefined {
+    return this.activeTasks.get(taskId);
+  }
+
+  cancelTask(taskId: string): boolean {
+    const task = this.activeTasks.get(taskId);
+    
+    if (!task) return false;
+    if (task.status !== "running" && task.status !== "pending") return false;
+
+    task.status = "failed";
+    task.error = "Cancelled by user";
+    task.completedAt = new Date();
+
+    this.log.info(`Cancelled sub-agent task`, { taskId });
+    return true;
+  }
+
+  listActiveTasks(): SubAgentTask[] {
+    return Array.from(this.activeTasks.values()).filter(
+      (t) => t.status === "running" || t.status === "pending"
+    );
+  }
+
+  cleanup(olderThanMs: number = 3600000): number {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [id, task] of this.activeTasks) {
+      const completedAt = task.completedAt?.getTime() ?? 0;
+      
+      if (task.status !== "running" && task.status !== "pending") {
+        if (now - completedAt > olderThanMs) {
+          this.activeTasks.delete(id);
+          cleaned++;
+        }
+      }
+    }
+
+    if (cleaned > 0) {
+      this.log.debug(`Cleaned up ${cleaned} completed sub-agent tasks`);
+    }
+
+    return cleaned;
+  }
+}
+
+export function createSubAgentManager(config: Config): SubAgentManager {
+  return new SubAgentManager(config);
+}
+
+export const sessionsSpawnTool = (
+  subAgentManager: SubAgentManager,
+  agentId: string,
+  sessionId: string
+): Tool => ({
+  name: "sessions_spawn",
+  description: "Spawn a sub-agent to complete a specific task",
+  parameters: {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        description: "The task for the sub-agent to complete",
+      },
+      tools: {
+        type: "array",
+        items: { type: "string" },
+        description: "Tools to delegate to the sub-agent (default: read, web_search)",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 60000)",
+      },
+    },
+    required: ["task"],
+  },
+  execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+    try {
+      const result = await subAgentManager.spawn(agentId, sessionId, {
+        task: params.task as string,
+        delegatedTools: params.tools as string[] | undefined,
+        timeout: params.timeout as number | undefined,
+      });
+
+      return {
+        success: result.status === "completed",
+        result: result.result,
+        error: result.error,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+      };
+    }
+  },
+});
+
+export const messageAgentTool = (
+  agentManager: any
+): Tool => ({
+  name: "message_agent",
+  description: "Send a message to another agent",
+  parameters: {
+    type: "object",
+    properties: {
+      agentId: {
+        type: "string",
+        description: "The ID of the target agent",
+      },
+      message: {
+        type: "string",
+        description: "The message to send",
+      },
+    },
+    required: ["agentId", "message"],
+  },
+  execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+    const targetAgentId = params.agentId as string;
+    const message = params.message as string;
+
+    if (!agentManager.hasAgent(targetAgentId)) {
+      return {
+        success: false,
+        error: `Agent not found: ${targetAgentId}`,
+      };
+    }
+
+    try {
+      return {
+        success: true,
+        result: {
+          delivered: true,
+          targetAgent: targetAgentId,
+          messageLength: message.length,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+      };
+    }
+  },
+});