@ebowwa/daemons 0.5.0

package/src/channels/base.ts

@@ -0,0 +1,573 @@
+/**
+ * Base Channel - Implements ChannelConnector from @ebowwa/channel-types
+ *
+ * Abstract base class for all communication channels (Telegram, Discord, etc.)
+ * Provides shared functionality for message routing, error handling, and conversation management.
+ */
+
+import {
+  type ChannelConnector,
+  type ChannelId,
+  type ChannelMessage,
+  type ChannelResponse,
+  type ChannelCapabilities,
+  type MessageHandler,
+  type MessageRef,
+  type ResponseContent,
+  type StreamChunk,
+  createChannelId,
+  createMessageRef,
+  RICH_CAPABILITIES,
+} from "@ebowwa/channel-types";
+import { GLMClient } from "@ebowwa/ai";
+import { ToolExecutor, BUILTIN_TOOLS } from "@ebowwa/ai/tools";
+import { GLMDaemon, type GLMDaemonConfig } from "../daemon.js";
+
+// ============================================================
+// CHANNEL CONFIG (extends base config from channel-types)
+// ============================================================
+
+export interface GLMChannelConfig {
+  /** Platform identifier */
+  platform: "telegram" | "discord" | "whatsapp" | "cli";
+
+  /** Account/bot ID */
+  accountId: string;
+
+  /** Instance ID for multiple instances */
+  instanceId?: string;
+
+  /** Butler storage directory */
+  butlerStorageDir?: string;
+
+  /** Working directory for daemon tasks */
+  daemonWorkdir?: string;
+
+  /** Base branch for daemon */
+  daemonBaseBranch?: string;
+
+  /** Auto-PR on completion */
+  enableDaemonAutoPR?: boolean;
+
+  /** Auto-commit during work */
+  enableDaemonAutoCommit?: boolean;
+}
+
+// ============================================================
+// INTERNAL TYPES (kept for compatibility)
+// ============================================================
+
+export interface MessageContext {
+  userId: string;
+  userName?: string;
+  channelId?: string;
+  timestamp: Date;
+}
+
+export interface RouteResult {
+  source: "butler" | "daemon" | "error";
+  response: string;
+  metadata?: {
+    daemonId?: string;
+    phase?: string;
+    executionTime?: number;
+  };
+}
+
+export interface MessageClassification {
+  type: "chat" | "task" | "status" | "unknown";
+  confidence: number;
+  suggestedAction: "handle_locally" | "delegate_daemon" | "both";
+}
+
+// Legacy config type for backwards compat
+export type BaseChannelConfig = GLMChannelConfig;
+
+// ============================================================
+// ABSTRACT BASE CHANNEL
+// ============================================================
+
+/**
+ * Abstract base class for communication channels.
+ * Implements ChannelConnector from @ebowwa/channel-types.
+ */
+export abstract class BaseChannel implements ChannelConnector {
+  // ChannelConnector interface
+  abstract readonly id: ChannelId;
+  abstract readonly label: string;
+  abstract readonly capabilities: ChannelCapabilities;
+
+  // Internal state
+  protected glmClient: GLMClient;
+  protected daemon: GLMDaemon | null = null;
+  protected activeDaemonTask: string | null = null;
+  protected config: GLMChannelConfig;
+  protected conversationHistory: Map<string, Array<{ role: string; content: string }>> = new Map();
+  protected messageHandler?: MessageHandler;
+  protected connected: boolean = false;
+
+  constructor(config: GLMChannelConfig) {
+    this.config = config;
+    this.glmClient = new GLMClient();
+  }
+
+  // ============================================================
+  // ChannelConnector Interface Implementation
+  // ============================================================
+
+  /**
+   * Start the channel
+   */
+  async start(): Promise<void> {
+    await this.startPlatform();
+    this.connected = true;
+  }
+
+  /**
+   * Stop the channel
+   */
+  async stop(): Promise<void> {
+    await this.stopPlatform();
+    await this.cleanup();
+    this.connected = false;
+  }
+
+  /**
+   * Register message handler (from ChannelConnector interface)
+   */
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  /**
+   * Send response (from ChannelConnector interface)
+   * Must be implemented by subclasses for platform-specific delivery
+   */
+  abstract send(response: ChannelResponse): Promise<void>;
+
+  /**
+   * Optional streaming support
+   */
+  async stream?(response: ChannelResponse, chunks: AsyncIterable<StreamChunk>): Promise<void>;
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  // ============================================================
+  // Platform-specific abstract methods
+  // ============================================================
+
+  /**
+   * Start the platform-specific bot (must be implemented by subclasses)
+   */
+  protected abstract startPlatform(): Promise<void>;
+
+  /**
+   * Stop the platform-specific bot (must be implemented by subclasses)
+   */
+  protected abstract stopPlatform(): Promise<void>;
+
+  // ============================================================
+  // Message Routing (Core Logic)
+  // ============================================================
+
+  /**
+   * Route a ChannelMessage through the internal handler or use default routing.
+   * This bridges ChannelMessage (from channel-types) to the internal routing logic.
+   */
+  async routeChannelMessage(message: ChannelMessage): Promise<ChannelResponse> {
+    // If external handler is registered, use it
+    if (this.messageHandler) {
+      return this.messageHandler(message) as Promise<ChannelResponse>;
+    }
+
+    // Otherwise use internal routing
+    const context: MessageContext = {
+      userId: message.sender.id,
+      userName: message.sender.displayName || message.sender.username,
+      channelId: message.context.groupName || message.channelId.accountId,
+      timestamp: message.timestamp,
+    };
+
+    const result = await this.routeMessage(message.text, context);
+
+    // Convert RouteResult to ChannelResponse
+    return this.resultToResponse(result, message);
+  }
+
+  /**
+   * Route a message to appropriate handler (internal routing logic)
+   */
+  async routeMessage(content: string, context: MessageContext): Promise<RouteResult> {
+    // Update conversation history
+    this.addToHistory(context.userId, { role: "user", content });
+
+    // Classify message
+    const classification = await this.classifyMessage(content);
+
+    console.log(
+      `[${this.constructor.name}] Message classified: ${classification.type} (${classification.confidence})`
+    );
+
+    // Route based on classification
+    switch (classification.type) {
+      case "chat":
+        return await this.handleChat(content, context);
+
+      case "task":
+        return await this.handleTask(content, context);
+
+      case "status":
+        return await this.handleStatus();
+
+      default:
+        return await this.handleUnknown(content);
+    }
+  }
+
+  /**
+   * Convert internal RouteResult to ChannelResponse
+   */
+  protected resultToResponse(result: RouteResult, originalMessage: ChannelMessage): ChannelResponse {
+    const replyTo: MessageRef = createMessageRef(
+      originalMessage.messageId,
+      originalMessage.channelId
+    );
+
+    const content: ResponseContent = {
+      text: result.response,
+      replyToOriginal: true,
+    };
+
+    return {
+      content,
+      replyTo,
+      isComplete: result.source !== "daemon" || !this.activeDaemonTask,
+      metadata: {
+        source: result.source,
+        ...result.metadata,
+      },
+    };
+  }
+
+  // ============================================================
+  // Message Classification
+  // ============================================================
+
+  /**
+   * Classify incoming message
+   */
+  protected async classifyMessage(content: string): Promise<MessageClassification> {
+    const lower = content.toLowerCase();
+
+    // Status queries
+    if (
+      lower.includes("status") ||
+      lower.includes("progress") ||
+      lower.includes("what are you doing")
+    ) {
+      return { type: "status", confidence: 0.95, suggestedAction: "handle_locally" };
+    }
+
+    // Task indicators
+    const taskKeywords = [
+      "implement",
+      "build",
+      "create",
+      "fix",
+      "add",
+      "remove",
+      "refactor",
+      "deploy",
+      "test",
+      "debug",
+      "optimize",
+      "write",
+      "generate code",
+      "make a",
+      "create a",
+      "build a",
+      "pr for",
+      "branch for",
+    ];
+
+    const hasTaskKeyword = taskKeywords.some((kw) => lower.includes(kw));
+    const isComplex = content.length > 100 || content.split("\n").length > 2;
+
+    if (hasTaskKeyword && isComplex) {
+      return { type: "task", confidence: 0.85, suggestedAction: "delegate_daemon" };
+    }
+
+    // Chat indicators
+    const chatKeywords = [
+      "hello",
+      "hi",
+      "hey",
+      "thanks",
+      "help",
+      "what can you",
+      "how are you",
+      "remember",
+      "tell me",
+      "explain",
+      "describe",
+      "list",
+    ];
+
+    const hasChatKeyword = chatKeywords.some((kw) => lower.includes(kw));
+
+    if (hasChatKeyword || !hasTaskKeyword) {
+      return { type: "chat", confidence: 0.75, suggestedAction: "handle_locally" };
+    }
+
+    return { type: "unknown", confidence: 0.5, suggestedAction: "handle_locally" };
+  }
+
+  // ============================================================
+  // Message Handlers
+  // ============================================================
+
+  /**
+   * Handle chat messages locally with GLM + tools
+   *
+   * Uses ToolExecutor from @ebowwa/ai/tools for the tool call loop.
+   * Refactored from manual tool loop on Feb 15, 2026.
+   */
+  protected async handleChat(content: string, context: MessageContext): Promise<RouteResult> {
+    const start = Date.now();
+
+    try {
+      const history = this.conversationHistory.get(context.userId) || [];
+
+      // Build system prompt with context
+      const systemPrompt = `You are a helpful AI assistant with tool access. You have access to conversation history and user context.
+
+User: ${context.userName || context.userId}
+Time: ${context.timestamp.toISOString()}
+Working Directory: ${this.config.daemonWorkdir || process.cwd()}
+
+You have access to tools for:
+- File operations (read_file, write_file, edit_file, list_dir)
+- Shell commands (run_command) - use for git, system info, etc.
+- Git operations (git_status)
+- System info (system_info)
+
+USE TOOLS when the user asks you to do something (not just chat). Examples:
+- "list files" → use list_dir
+- "read package.json" → use read_file
+- "what's the git status" → use git_status
+- "run npm test" → use run_command
+
+Always use tools when appropriate. Be helpful and execute tasks.`;
+
+      // Build messages array from history (exclude system - ToolExecutor adds it)
+      const messages = [
+        ...history.slice(-10).map(msg => ({
+          role: msg.role as "user" | "assistant",
+          content: msg.content
+        })),
+        { role: "user" as const, content }
+      ];
+
+      // Use ToolExecutor from @ebowwa/ai/tools
+      const executor = new ToolExecutor(this.glmClient, BUILTIN_TOOLS);
+      const result = await executor.executeWithTools(messages, {
+        systemPrompt,
+        maxIterations: 100,  // High limit for complex tasks (was 5)
+        temperature: 0.7,
+        maxTokens: 4096,
+        logger: (msg: string) => console.log(`[${this.constructor.name}] ${msg}`),
+      });
+
+      const responseText = result.content;
+
+      this.addToHistory(context.userId, { role: "assistant", content: responseText });
+
+      return {
+        source: "butler",
+        response: responseText,
+        metadata: { executionTime: Date.now() - start, toolIterations: result.iterations },
+      };
+    } catch (error) {
+      console.error(`[${this.constructor.name}] handleChat error:`, error);
+      return {
+        source: "error",
+        response: `Sorry, I encountered an error: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Handle task messages by delegating to GLMDaemon
+   */
+  protected async handleTask(content: string, context: MessageContext): Promise<RouteResult> {
+    const start = Date.now();
+
+    if (this.activeDaemonTask && this.daemon) {
+      const status = this.daemon.getStatus();
+      return {
+        source: "daemon",
+        response: `I'm currently working on: "${this.activeDaemonTask}"\n\nStatus: ${status?.phase || "unknown"}\n\nPlease wait for this to complete, or use "stop" to cancel it.`,
+        metadata: {
+          daemonId: status?.id,
+          phase: status?.phase,
+        },
+      };
+    }
+
+    if (content.toLowerCase().includes("stop") && this.daemon) {
+      await this.daemon.stop();
+      this.daemon = null;
+      this.activeDaemonTask = null;
+      return {
+        source: "daemon",
+        response: "Task stopped. Ready for new instructions.",
+      };
+    }
+
+    try {
+      const daemonConfig: GLMDaemonConfig = {
+        cwd: this.config.daemonWorkdir || process.cwd(),
+        teamName: `${this.constructor.name.toLowerCase()}-task-${Date.now()}`,
+        model: "glm-4.7",
+        autoCommit: this.config.enableDaemonAutoCommit || false,
+        autoPR: this.config.enableDaemonAutoPR || false,
+        baseBranch: this.config.daemonBaseBranch || "dev",
+        completionPromise: "TASK_COMPLETE",
+      };
+
+      this.daemon = new GLMDaemon(daemonConfig);
+      this.activeDaemonTask = content;
+
+      const teamName = await this.daemon.start(content);
+      const status = this.daemon.getStatus();
+
+      return {
+        source: "daemon",
+        response: `Started working on: "${content}"\n\nTeam: ${teamName}\nPhase: ${status.phase}\n\nI'll work through this using SLAM (Planning → Executing → Reviewing → Fixing → Committing).\n\nCheck status anytime with "status" or "progress".`,
+        metadata: {
+          daemonId: status.id,
+          phase: status.phase,
+          executionTime: Date.now() - start,
+        },
+      };
+    } catch (error) {
+      this.daemon = null;
+      this.activeDaemonTask = null;
+      return {
+        source: "error",
+        response: `Failed to start task: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Handle status queries
+   */
+  protected async handleStatus(): Promise<RouteResult> {
+    const parts: string[] = [];
+
+    parts.push("**Butler (Chat):** Ready");
+    parts.push("- Memory: Active");
+    parts.push("- Scheduled tasks: Running");
+
+    if (this.daemon && this.activeDaemonTask) {
+      const status = this.daemon.getStatus();
+      parts.push(`\n**Daemon (Task):** Active`);
+      parts.push(`- Task: "${this.activeDaemonTask}"`);
+      parts.push(`- Phase: ${status.phase}`);
+      parts.push(`- Iteration: ${status.iteration}`);
+      parts.push(`- Team: ${status.id}`);
+
+      if (status.totalSubtasks > 0) {
+        parts.push(`- Progress: ${status.completedSubtasks}/${status.totalSubtasks} subtasks`);
+      }
+    } else {
+      parts.push("\n**Daemon (Task):** Idle");
+    }
+
+    parts.push(`\n**System:**`);
+    parts.push(`- Active conversations: ${this.conversationHistory.size}`);
+    parts.push(`- Uptime: ${process.uptime().toFixed(0)}s`);
+
+    return {
+      source: "butler",
+      response: parts.join("\n"),
+    };
+  }
+
+  /**
+   * Handle unknown messages - ask for clarification
+   */
+  protected async handleUnknown(content: string): Promise<RouteResult> {
+    return {
+      source: "butler",
+      response: `I'm not sure what you want me to do with: "${content}"\n\n**Quick guide:**\n- For questions, chat, or status → I handle directly\n- For coding tasks, bug fixes, or features → I'll use the daemon\n- Example: "implement a new feature" → Daemon\n- Example: "what can you do?" → Butler\n\nCould you clarify what you need?`,
+    };
+  }
+
+  // ============================================================
+  // Utilities
+  // ============================================================
+
+  /**
+   * Add message to conversation history
+   */
+  protected addToHistory(userId: string, message: { role: string; content: string }): void {
+    if (!this.conversationHistory.has(userId)) {
+      this.conversationHistory.set(userId, []);
+    }
+
+    const history = this.conversationHistory.get(userId)!;
+    history.push(message);
+
+    if (history.length > 20) {
+      history.splice(0, history.length - 20);
+    }
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus(): {
+    hasActiveDaemon: boolean;
+    activeTask: string | null;
+    conversationCount: number;
+    daemonPhase: string | null;
+  } {
+    return {
+      hasActiveDaemon: this.daemon !== null,
+      activeTask: this.activeDaemonTask,
+      conversationCount: this.conversationHistory.size,
+      daemonPhase: this.daemon?.getStatus()?.phase || null,
+    };
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup(): Promise<void> {
+    if (this.daemon) {
+      await this.daemon.stop();
+      this.daemon = null;
+    }
+
+    this.conversationHistory.clear();
+    this.activeDaemonTask = null;
+  }
+
+  /**
+   * Helper to create ChannelId for this channel
+   */
+  protected createId(): ChannelId {
+    return createChannelId(
+      this.config.platform,
+      this.config.accountId,
+      this.config.instanceId
+    );
+  }
+}