@johpaz/hive-core 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-core",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Hive Gateway — Personal AI agent runtime",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -23,9 +23,12 @@
     "@slack/bolt": "latest",
     "grammy": "latest",
     "discord.js": "latest",
+    "@sapphire/snowflake": "latest",
     "js-yaml": "latest",
     "zod": "latest",
-    "qrcode-terminal": "latest"
+    "qrcode-terminal": "latest",
+    "@johpaz/hive-skills": "workspace:*",
+    "@johpaz/hive-mcp": "workspace:*"
   },
   "devDependencies": {
     "typescript": "latest",

package/src/agent/index.ts

@@ -1,11 +1,15 @@
 import type { Config } from "../config/loader.ts";
-import { loadSoul } from "./soul.ts";
-import { loadUser } from "./user.ts";
-import { loadEthics, type EthicsConfig, DEFAULT_ETHICS } from "./ethics.ts";
+import { loadSoul, watchSoul, type SoulConfig } from "./soul.ts";
+import { loadUser, watchUser, type UserConfig } from "./user.ts";
+import { loadEthics, watchEthics, type EthicsConfig, DEFAULT_ETHICS } from "./ethics.ts";
 import { buildSystemPrompt } from "./context.ts";
 import { logger } from "../utils/logger.ts";
-import * as path from "node:path";
-import * as fs from "node:fs";
+import { SkillLoader, type Skill } from "@johpaz/hive-skills";
+import { MCPClientManager, createMCPManager } from "@johpaz/hive-mcp";
+import * as path from "path";
+import * as fs from "fs";
+
+export { watchEthics, watchSoul, watchUser };
 
 export interface AgentOptions {
   agentId: string;
@@ -18,6 +22,12 @@ export class Agent {
   readonly workspacePath: string;
   private config: Config;
   private ethics: EthicsConfig | null = null;
+  private soul: SoulConfig | null = null;
+  private user: UserConfig | null = null;
+  private skills: Skill[] = [];
+  private skillLoader: SkillLoader | null = null;
+  private mcpManager: MCPClientManager | null = null;
+  private memory: string[] = [];
   private log = logger.child("agent");
 
   constructor(options: AgentOptions) {
@@ -28,26 +38,75 @@ export class Agent {
 
   async initialize(): Promise<void> {
     this.log.info(`Initializing agent: ${this.agentId}`);
-    
-    const soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
-    const user = loadUser(path.join(this.workspacePath, "USER.md"));
+
+    this.soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
+    this.user = loadUser(path.join(this.workspacePath, "USER.md"));
     this.ethics = await loadEthics(path.join(this.workspacePath, "ETHICS.md"));
 
-    if (soul) {
+    if (this.soul) {
       this.log.debug(`Loaded SOUL.md for agent ${this.agentId}`);
     }
-    if (user) {
+    if (this.user) {
       this.log.debug(`Loaded USER.md for agent ${this.agentId}`);
     }
     if (this.ethics) {
       this.log.debug(`Loaded ETHICS.md for agent ${this.agentId}`);
     }
+
+    // Load skills
+    this.skillLoader = new SkillLoader({
+      skills: this.config.skills,
+      workspacePath: this.workspacePath,
+    });
+    this.skills = this.skillLoader.loadAllSkills();
+    this.log.debug(`Loaded ${this.skills.length} skills for agent ${this.agentId}`);
+
+    // Load MCP
+    if (this.config.mcp?.enabled !== false) {
+      this.mcpManager = createMCPManager(this.config.mcp || {});
+      await this.mcpManager.initialize();
+      try {
+        await this.mcpManager.connectAll();
+      } catch (error) {
+        this.log.warn(`Some MCP servers failed to connect: ${(error as Error).message}`);
+      }
+      this.log.debug(`MCP Manager initialized for agent ${this.agentId}`);
+    }
+
+    // Load memory notes
+    this.memory = this.loadMemoryNotes();
+    if (this.memory.length > 0) {
+      this.log.debug(`Loaded ${this.memory.length} memory notes`);
+    }
+  }
+
+  private loadMemoryNotes(): string[] {
+    const memoryDir = path.join(this.workspacePath, "memory");
+    const notes: string[] = [];
+
+    if (!fs.existsSync(memoryDir)) {
+      return notes;
+    }
+
+    try {
+      const files = fs.readdirSync(memoryDir).filter(f => f.endsWith(".md"));
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(memoryDir, file), "utf-8");
+        // Extract body from frontmatter if present
+        const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+        const body = match ? match[1]!.trim() : content.trim();
+        if (body) {
+          notes.push(body);
+        }
+      }
+    } catch (error) {
+      this.log.warn(`Failed to load memory notes: ${(error as Error).message}`);
+    }
+
+    return notes;
   }
 
   buildPrompt(): string {
-    const soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
-    const user = loadUser(path.join(this.workspacePath, "USER.md"));
-    
     const ethicsConfig = this.ethics ?? {
       raw: DEFAULT_ETHICS,
       loadedAt: new Date(),
@@ -56,7 +115,7 @@ export class Agent {
 
     return buildSystemPrompt({
       ethics: ethicsConfig,
-      soul: soul ?? {
+      soul: this.soul ?? {
         identity: "",
         personality: "",
         boundaries: "",
@@ -64,13 +123,78 @@ export class Agent {
         capabilities: [],
         raw: "",
       },
-      user,
-      skills: [],
-      memory: [],
+      user: this.user,
+      skills: this.skills.map(s => s.content),
+      memory: this.memory,
       maxTokens: this.config.agent?.context?.maxTokens ?? 128000,
     });
   }
 
+  reloadSoul(): void {
+    this.soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
+    this.log.info("SOUL.md recargado");
+  }
+
+  reloadUser(): void {
+    this.user = loadUser(path.join(this.workspacePath, "USER.md"));
+    this.log.info("USER.md recargado");
+  }
+
+  async reloadEthics(): Promise<void> {
+    this.ethics = await loadEthics(path.join(this.workspacePath, "ETHICS.md"));
+    this.log.info("ETHICS.md recargado");
+  }
+
+  reloadSkills(): void {
+    if (this.skillLoader) {
+      this.skillLoader.clearCache();
+      this.skills = this.skillLoader.loadAllSkills();
+      this.log.info(`Skills recargadas: ${this.skills.length} skills`);
+    }
+  }
+
+  reloadMemory(): void {
+    this.memory = this.loadMemoryNotes();
+    this.log.info(`Memoria recargada: ${this.memory.length} notas`);
+  }
+
+  async reload(): Promise<void> {
+    this.soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
+    this.user = loadUser(path.join(this.workspacePath, "USER.md"));
+    this.ethics = await loadEthics(path.join(this.workspacePath, "ETHICS.md"));
+    this.reloadSkills();
+    this.reloadMemory();
+    this.log.info("Agente recargado completamente");
+  }
+
+  async updateConfig(config: Config): Promise<void> {
+    this.config = config;
+    if (this.mcpManager) {
+      await this.mcpManager.updateConfig(this.config.mcp || {});
+    }
+    this.log.info("Configuración actualizada");
+  }
+
+  getEthics(): EthicsConfig | null {
+    return this.ethics;
+  }
+
+  getSoul(): SoulConfig | null {
+    return this.soul;
+  }
+
+  getUser(): UserConfig | null {
+    return this.user;
+  }
+
+  getSkills(): Skill[] {
+    return this.skills;
+  }
+
+  getMemory(): string[] {
+    return this.memory;
+  }
+
   getConfig(): Config {
     return this.config;
   }
@@ -78,4 +202,8 @@ export class Agent {
   getWorkspacePath(): string {
     return this.workspacePath;
   }
+
+  getMCPManager(): MCPClientManager | null {
+    return this.mcpManager;
+  }
 }

package/src/agent/providers/index.ts

@@ -218,6 +218,14 @@ export class AgentRunner {
           options.onToken(chunk);
         }
 
+        if (!fullText || fullText.trim().length === 0) {
+          this.log.warn(`Empty response from LLM (streaming)`, {
+            provider,
+            model: resolved.name,
+          });
+          fullText = "...";
+        }
+
         return {
           content: fullText,
           usage: {
@@ -236,6 +244,17 @@ export class AgentRunner {
         temperature: options.temperature ?? 0.7,
       });
 
+      let responseText = result.text ?? "";
+      
+      if (!responseText || responseText.trim().length === 0) {
+        this.log.warn(`Empty response from LLM, using fallback`, {
+          provider,
+          model: resolved.name,
+          hadToolCalls: (result.toolCalls?.length ?? 0) > 0,
+        });
+        responseText = "...";
+      }
+
       const toolCalls = result.toolCalls?.map((tc) => {
         const t = tc as unknown as { toolCallId: string; toolName: string; input: Record<string, unknown> };
         return {
@@ -246,7 +265,7 @@ export class AgentRunner {
       });
 
       return {
-        content: result.text,
+        content: responseText,
         toolCalls,
         usage: {
           promptTokens: 0,

package/src/agent/workspace.ts

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+
+export type WorkspaceFile = "soul" | "user" | "ethics";
+
+export class WorkspaceLoader {
+  private cache: Map<WorkspaceFile, string> = new Map();
+  private watchers: Map<WorkspaceFile, fs.FSWatcher> = new Map();
+  private workspaceDir: string;
+
+  constructor(workspaceDir: string) {
+    this.workspaceDir = workspaceDir;
+  }
+
+  private getPath(file: WorkspaceFile): string {
+    const names: Record<WorkspaceFile, string> = {
+      soul: "SOUL.md",
+      user: "USER.md",
+      ethics: "ETHICS.md",
+    };
+    return path.join(this.workspaceDir, names[file]);
+  }
+
+  async read(file: WorkspaceFile): Promise<string> {
+    const filePath = this.getPath(file);
+    try {
+      const content = await fsPromises.readFile(filePath, "utf-8");
+      this.cache.set(file, content);
+      return content;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        this.cache.set(file, "");
+        return "";
+      }
+      logger.error(`Failed to read ${file}.md: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  async write(file: WorkspaceFile, content: string): Promise<void> {
+    if (file === "ethics") {
+      throw new Error(
+        "ETHICS.md cannot be modified programmatically. Only the operator can edit it directly."
+      );
+    }
+
+    const filePath = this.getPath(file);
+    await fsPromises.writeFile(filePath, content, "utf-8");
+    await fsPromises.chmod(filePath, 0o644);
+    this.cache.set(file, content);
+    logger.info(`Workspace: Updated ${file}.md`);
+  }
+
+  async patch(file: WorkspaceFile, section: string, newContent: string): Promise<void> {
+    if (file === "ethics") {
+      throw new Error("ETHICS.md cannot be modified programmatically.");
+    }
+
+    const current = await this.read(file);
+    const patched = this.patchSection(current, section, newContent);
+    await this.write(file, patched);
+  }
+
+  async append(file: WorkspaceFile, section: string, content: string): Promise<void> {
+    if (file === "ethics") {
+      throw new Error("ETHICS.md cannot be modified programmatically.");
+    }
+
+    const current = await this.read(file);
+    const sectionHeader = `## ${section}`;
+
+    if (current.includes(sectionHeader)) {
+      const patched = current.replace(
+        new RegExp(`(${sectionHeader}[\\s\\S]*?)(?=\\n## |$)`),
+        `$1\n${content}`
+      );
+      await this.write(file, patched);
+    } else {
+      await this.write(file, `${current}\n\n${sectionHeader}\n${content}`);
+    }
+  }
+
+  async reload(): Promise<void> {
+    for (const file of ["soul", "user", "ethics"] as WorkspaceFile[]) {
+      await this.read(file);
+    }
+  }
+
+  private patchSection(content: string, section: string, newContent: string): string {
+    const header = `## ${section}`;
+    const regex = new RegExp(
+      `(${header})([\\s\\S]*?)(?=\\n## |$)`,
+      "m"
+    );
+
+    if (content.match(regex)) {
+      return content.replace(regex, `$1\n\n${newContent}\n`);
+    }
+
+    return `${content}\n\n${header}\n\n${newContent}\n`;
+  }
+
+  closeWatchers(): void {
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+  }
+}

package/src/channels/base.ts

@@ -39,6 +39,9 @@ export interface IChannel {
   send(sessionId: string, message: OutboundMessage): Promise<void>;
   onMessage(handler: MessageHandler): void;
   isRunning(): boolean;
+  startTyping?(sessionId: string): Promise<void>;
+  stopTyping?(sessionId: string): Promise<void>;
+  markAsRead?(sessionId: string, messageId?: string): Promise<void>;
 }
 
 export type MessageHandler = (message: IncomingMessage) => Promise<void>;
@@ -50,6 +53,7 @@ export abstract class BaseChannel implements IChannel {
   
   protected messageHandler?: MessageHandler;
   protected running = false;
+  protected typingIntervals: Map<string, Timer> = new Map();
 
   abstract start(): Promise<void>;
   abstract stop(): Promise<void>;
@@ -63,6 +67,22 @@ export abstract class BaseChannel implements IChannel {
     return this.running;
   }
 
+  async startTyping(_sessionId: string): Promise<void> {
+    // Default: no-op, override in subclasses
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const interval = this.typingIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(sessionId);
+    }
+  }
+
+  async markAsRead(_sessionId: string, _messageId?: string): Promise<void> {
+    // Default: no-op, override in subclasses
+  }
+
   protected async handleMessage(message: IncomingMessage): Promise<void> {
     if (this.messageHandler) {
       await this.messageHandler(message);
@@ -74,12 +94,18 @@ export abstract class BaseChannel implements IChannel {
       return true;
     }
 
+    const normalizedPeerId = `tg:${peerId}`;
+
     if (this.config.dmPolicy === "allowlist") {
-      return this.config.allowFrom.includes(peerId);
+      return this.config.allowFrom.some(
+        (allowed) => allowed === peerId || allowed === normalizedPeerId
+      );
     }
 
     if (this.config.dmPolicy === "pairing") {
-      return this.config.allowFrom.includes(peerId);
+      return this.config.allowFrom.some(
+        (allowed) => allowed === peerId || allowed === normalizedPeerId
+      );
     }
 
     return false;

package/src/channels/discord.ts

@@ -25,6 +25,7 @@ export class DiscordChannel extends BaseChannel {
   
   private client?: Client;
   private log = logger.child("discord");
+  private channelCache: Map<string, DiscordTextChannel> = new Map();
 
   constructor(accountId: string, config: DiscordConfig) {
     super();
@@ -81,8 +82,13 @@ export class DiscordChannel extends BaseChannel {
       return;
     }
 
+    const sessionId = this.formatSessionId(peerId, kind);
+    if (message.channel.isTextBased()) {
+      this.channelCache.set(sessionId, message.channel as DiscordTextChannel);
+    }
+
     const incomingMessage: IncomingMessage = {
-      sessionId: this.formatSessionId(peerId, kind),
+      sessionId,
       channel: "discord",
       accountId: this.accountId,
       peerId,
@@ -114,10 +120,11 @@ export class DiscordChannel extends BaseChannel {
     }
   }
 
-  async send(sessionId: string, message: OutboundMessage): Promise<void> {
-    if (!this.client) {
-      throw new Error("Discord client not started");
-    }
+  private async getChannel(sessionId: string): Promise<DiscordTextChannel | null> {
+    const cached = this.channelCache.get(sessionId);
+    if (cached) return cached;
+
+    if (!this.client) return null;
 
     const parts = sessionId.split(":");
     const peerPart = parts.slice(3).join(":");
@@ -130,10 +137,51 @@ export class DiscordChannel extends BaseChannel {
       channelId = peerPart;
     }
 
-    const channel = await this.client.channels.fetch(channelId);
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (channel && channel.isTextBased()) {
+        this.channelCache.set(sessionId, channel as DiscordTextChannel);
+        return channel as DiscordTextChannel;
+      }
+    } catch {
+      // Channel not found
+    }
+
+    return null;
+  }
+
+  async startTyping(sessionId: string): Promise<void> {
+    const channel = await this.getChannel(sessionId);
+    if (!channel) return;
+
+    await channel.sendTyping();
+
+    const interval = setInterval(async () => {
+      try {
+        await channel.sendTyping();
+      } catch {
+        this.stopTyping(sessionId);
+      }
+    }, 8000);
+
+    this.typingIntervals.set(sessionId, interval);
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const interval = this.typingIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(sessionId);
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    await this.stopTyping(sessionId);
+
+    const channel = await this.getChannel(sessionId);
     
-    if (!channel || !channel.isTextBased()) {
-      throw new Error(`Channel not found or not text-based: ${channelId}`);
+    if (!channel) {
+      throw new Error(`Channel not found for session: ${sessionId}`);
     }
 
     const content = message.content ?? "";
@@ -141,11 +189,11 @@ export class DiscordChannel extends BaseChannel {
 
     try {
       if (content.length <= maxLength) {
-        await (channel as DiscordTextChannel).send(content);
+        await channel.send(content);
       } else {
         const chunks = this.chunkMessage(content, maxLength);
         for (const chunk of chunks) {
-          await (channel as DiscordTextChannel).send(chunk);
+          await channel.send(chunk);
         }
       }
     } catch (error) {