@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/channels/base.js

@@ -0,0 +1,509 @@
+"use strict";
+/**
+ * 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.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseChannel = void 0;
+var channel_types_1 = require("@ebowwa/channel-types");
+var ai_1 = require("@ebowwa/ai");
+var glm_daemon_1 = require("@ebowwa/glm-daemon");
+// ============================================================
+// ABSTRACT BASE CHANNEL
+// ============================================================
+/**
+ * Abstract base class for communication channels.
+ * Implements ChannelConnector from @ebowwa/channel-types.
+ */
+var BaseChannel = /** @class */ (function () {
+    function BaseChannel(config) {
+        this.daemon = null;
+        this.activeDaemonTask = null;
+        this.conversationHistory = new Map();
+        this.connected = false;
+        this.config = config;
+        this.glmClient = new ai_1.GLMClient();
+    }
+    // ============================================================
+    // ChannelConnector Interface Implementation
+    // ============================================================
+    /**
+     * Start the channel
+     */
+    BaseChannel.prototype.start = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.startPlatform()];
+                    case 1:
+                        _a.sent();
+                        this.connected = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop the channel
+     */
+    BaseChannel.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.stopPlatform()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.cleanup()];
+                    case 2:
+                        _a.sent();
+                        this.connected = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register message handler (from ChannelConnector interface)
+     */
+    BaseChannel.prototype.onMessage = function (handler) {
+        this.messageHandler = handler;
+    };
+    /**
+     * Check if connected
+     */
+    BaseChannel.prototype.isConnected = function () {
+        return this.connected;
+    };
+    // ============================================================
+    // 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.
+     */
+    BaseChannel.prototype.routeChannelMessage = function (message) {
+        return __awaiter(this, void 0, void 0, function () {
+            var context, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // If external handler is registered, use it
+                        if (this.messageHandler) {
+                            return [2 /*return*/, this.messageHandler(message)];
+                        }
+                        context = {
+                            userId: message.sender.id,
+                            userName: message.sender.displayName || message.sender.username,
+                            channelId: message.context.groupName || message.channelId.accountId,
+                            timestamp: message.timestamp,
+                        };
+                        return [4 /*yield*/, this.routeMessage(message.text, context)];
+                    case 1:
+                        result = _a.sent();
+                        // Convert RouteResult to ChannelResponse
+                        return [2 /*return*/, this.resultToResponse(result, message)];
+                }
+            });
+        });
+    };
+    /**
+     * Route a message to appropriate handler (internal routing logic)
+     */
+    BaseChannel.prototype.routeMessage = function (content, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var classification, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // Update conversation history
+                        this.addToHistory(context.userId, { role: "user", content: content });
+                        return [4 /*yield*/, this.classifyMessage(content)];
+                    case 1:
+                        classification = _b.sent();
+                        console.log("[".concat(this.constructor.name, "] Message classified: ").concat(classification.type, " (").concat(classification.confidence, ")"));
+                        _a = classification.type;
+                        switch (_a) {
+                            case "chat": return [3 /*break*/, 2];
+                            case "task": return [3 /*break*/, 4];
+                            case "status": return [3 /*break*/, 6];
+                        }
+                        return [3 /*break*/, 8];
+                    case 2: return [4 /*yield*/, this.handleChat(content, context)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [4 /*yield*/, this.handleTask(content, context)];
+                    case 5: return [2 /*return*/, _b.sent()];
+                    case 6: return [4 /*yield*/, this.handleStatus()];
+                    case 7: return [2 /*return*/, _b.sent()];
+                    case 8: return [4 /*yield*/, this.handleUnknown(content)];
+                    case 9: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Convert internal RouteResult to ChannelResponse
+     */
+    BaseChannel.prototype.resultToResponse = function (result, originalMessage) {
+        var replyTo = (0, channel_types_1.createMessageRef)(originalMessage.messageId, originalMessage.channelId);
+        var content = {
+            text: result.response,
+            replyToOriginal: true,
+        };
+        return {
+            content: content,
+            replyTo: replyTo,
+            isComplete: result.source !== "daemon" || !this.activeDaemonTask,
+            metadata: __assign({ source: result.source }, result.metadata),
+        };
+    };
+    // ============================================================
+    // Message Classification
+    // ============================================================
+    /**
+     * Classify incoming message
+     */
+    BaseChannel.prototype.classifyMessage = function (content) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lower, taskKeywords, hasTaskKeyword, isComplex, chatKeywords, hasChatKeyword;
+            return __generator(this, function (_a) {
+                lower = content.toLowerCase();
+                // Status queries
+                if (lower.includes("status") ||
+                    lower.includes("progress") ||
+                    lower.includes("what are you doing")) {
+                    return [2 /*return*/, { type: "status", confidence: 0.95, suggestedAction: "handle_locally" }];
+                }
+                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",
+                ];
+                hasTaskKeyword = taskKeywords.some(function (kw) { return lower.includes(kw); });
+                isComplex = content.length > 100 || content.split("\n").length > 2;
+                if (hasTaskKeyword && isComplex) {
+                    return [2 /*return*/, { type: "task", confidence: 0.85, suggestedAction: "delegate_daemon" }];
+                }
+                chatKeywords = [
+                    "hello",
+                    "hi",
+                    "hey",
+                    "thanks",
+                    "help",
+                    "what can you",
+                    "how are you",
+                    "remember",
+                    "tell me",
+                    "explain",
+                    "describe",
+                    "list",
+                ];
+                hasChatKeyword = chatKeywords.some(function (kw) { return lower.includes(kw); });
+                if (hasChatKeyword || !hasTaskKeyword) {
+                    return [2 /*return*/, { type: "chat", confidence: 0.75, suggestedAction: "handle_locally" }];
+                }
+                return [2 /*return*/, { type: "unknown", confidence: 0.5, suggestedAction: "handle_locally" }];
+            });
+        });
+    };
+    // ============================================================
+    // Message Handlers
+    // ============================================================
+    /**
+     * Handle chat messages locally with GLM
+     */
+    BaseChannel.prototype.handleChat = function (content, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, history_1, systemPrompt, messages, response, responseText, error_1;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        start = Date.now();
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        history_1 = this.conversationHistory.get(context.userId) || [];
+                        systemPrompt = "You are a helpful AI assistant. You have access to conversation history and user context.\n\nUser: ".concat(context.userName || context.userId, "\nTime: ").concat(context.timestamp.toISOString(), "\n\nBe concise, helpful, and friendly. If the user asks about your capabilities, explain that you can:\n- Answer questions and have conversations\n- Handle coding tasks by delegating to a specialized daemon\n- Check status of ongoing work\n\nFor complex coding tasks, suggest the user phrase it as a task request.");
+                        messages = __spreadArray(__spreadArray([
+                            { role: "system", content: systemPrompt }
+                        ], history_1.slice(-10).map(function (msg) { return ({
+                            role: msg.role,
+                            content: msg.content
+                        }); }), true), [
+                            { role: "user", content: content }
+                        ], false);
+                        return [4 /*yield*/, this.glmClient.chatCompletion(messages, {
+                                temperature: 0.7,
+                                maxTokens: 4096
+                            })];
+                    case 2:
+                        response = _d.sent();
+                        responseText = ((_c = (_b = (_a = response.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) || String(response);
+                        this.addToHistory(context.userId, { role: "assistant", content: responseText });
+                        return [2 /*return*/, {
+                                source: "butler",
+                                response: responseText,
+                                metadata: { executionTime: Date.now() - start },
+                            }];
+                    case 3:
+                        error_1 = _d.sent();
+                        return [2 /*return*/, {
+                                source: "error",
+                                response: "Sorry, I encountered an error: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Handle task messages by delegating to GLMDaemon
+     */
+    BaseChannel.prototype.handleTask = function (content, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, status_1, daemonConfig, teamName, status_2, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        start = Date.now();
+                        if (this.activeDaemonTask && this.daemon) {
+                            status_1 = this.daemon.getStatus();
+                            return [2 /*return*/, {
+                                    source: "daemon",
+                                    response: "I'm currently working on: \"".concat(this.activeDaemonTask, "\"\n\nStatus: ").concat((status_1 === null || status_1 === void 0 ? void 0 : status_1.phase) || "unknown", "\n\nPlease wait for this to complete, or use \"stop\" to cancel it."),
+                                    metadata: {
+                                        daemonId: status_1 === null || status_1 === void 0 ? void 0 : status_1.id,
+                                        phase: status_1 === null || status_1 === void 0 ? void 0 : status_1.phase,
+                                    },
+                                }];
+                        }
+                        if (!(content.toLowerCase().includes("stop") && this.daemon)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.daemon.stop()];
+                    case 1:
+                        _a.sent();
+                        this.daemon = null;
+                        this.activeDaemonTask = null;
+                        return [2 /*return*/, {
+                                source: "daemon",
+                                response: "Task stopped. Ready for new instructions.",
+                            }];
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        daemonConfig = {
+                            cwd: this.config.daemonWorkdir || process.cwd(),
+                            teamName: "".concat(this.constructor.name.toLowerCase(), "-task-").concat(Date.now()),
+                            model: "glm-4.7",
+                            autoCommit: this.config.enableDaemonAutoCommit || false,
+                            autoPR: this.config.enableDaemonAutoPR || false,
+                            baseBranch: this.config.daemonBaseBranch || "dev",
+                            enableWorktree: true,
+                            completionPromise: "TASK_COMPLETE",
+                        };
+                        this.daemon = new glm_daemon_1.GLMDaemon(daemonConfig);
+                        this.activeDaemonTask = content;
+                        return [4 /*yield*/, this.daemon.start(content)];
+                    case 3:
+                        teamName = _a.sent();
+                        status_2 = this.daemon.getStatus();
+                        return [2 /*return*/, {
+                                source: "daemon",
+                                response: "Started working on: \"".concat(content, "\"\n\nTeam: ").concat(teamName, "\nPhase: ").concat(status_2.phase, "\n\nI'll work through this using SLAM (Planning \u2192 Executing \u2192 Reviewing \u2192 Fixing \u2192 Committing).\n\nCheck status anytime with \"status\" or \"progress\"."),
+                                metadata: {
+                                    daemonId: status_2.id,
+                                    phase: status_2.phase,
+                                    executionTime: Date.now() - start,
+                                },
+                            }];
+                    case 4:
+                        error_2 = _a.sent();
+                        this.daemon = null;
+                        this.activeDaemonTask = null;
+                        return [2 /*return*/, {
+                                source: "error",
+                                response: "Failed to start task: ".concat(error_2 instanceof Error ? error_2.message : String(error_2)),
+                            }];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Handle status queries
+     */
+    BaseChannel.prototype.handleStatus = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var parts, status_3;
+            return __generator(this, function (_a) {
+                parts = [];
+                parts.push("**Butler (Chat):** Ready");
+                parts.push("- Memory: Active");
+                parts.push("- Scheduled tasks: Running");
+                if (this.daemon && this.activeDaemonTask) {
+                    status_3 = this.daemon.getStatus();
+                    parts.push("\n**Daemon (Task):** Active");
+                    parts.push("- Task: \"".concat(this.activeDaemonTask, "\""));
+                    parts.push("- Phase: ".concat(status_3.phase));
+                    parts.push("- Iteration: ".concat(status_3.iteration));
+                    parts.push("- Team: ".concat(status_3.id));
+                    if (status_3.totalSubtasks > 0) {
+                        parts.push("- Progress: ".concat(status_3.completedSubtasks, "/").concat(status_3.totalSubtasks, " subtasks"));
+                    }
+                }
+                else {
+                    parts.push("\n**Daemon (Task):** Idle");
+                }
+                parts.push("\n**System:**");
+                parts.push("- Active conversations: ".concat(this.conversationHistory.size));
+                parts.push("- Uptime: ".concat(process.uptime().toFixed(0), "s"));
+                return [2 /*return*/, {
+                        source: "butler",
+                        response: parts.join("\n"),
+                    }];
+            });
+        });
+    };
+    /**
+     * Handle unknown messages - ask for clarification
+     */
+    BaseChannel.prototype.handleUnknown = function (content) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        source: "butler",
+                        response: "I'm not sure what you want me to do with: \"".concat(content, "\"\n\n**Quick guide:**\n- For questions, chat, or status \u2192 I handle directly\n- For coding tasks, bug fixes, or features \u2192 I'll use the daemon\n- Example: \"implement a new feature\" \u2192 Daemon\n- Example: \"what can you do?\" \u2192 Butler\n\nCould you clarify what you need?"),
+                    }];
+            });
+        });
+    };
+    // ============================================================
+    // Utilities
+    // ============================================================
+    /**
+     * Add message to conversation history
+     */
+    BaseChannel.prototype.addToHistory = function (userId, message) {
+        if (!this.conversationHistory.has(userId)) {
+            this.conversationHistory.set(userId, []);
+        }
+        var history = this.conversationHistory.get(userId);
+        history.push(message);
+        if (history.length > 20) {
+            history.splice(0, history.length - 20);
+        }
+    };
+    /**
+     * Get current status
+     */
+    BaseChannel.prototype.getStatus = function () {
+        var _a, _b;
+        return {
+            hasActiveDaemon: this.daemon !== null,
+            activeTask: this.activeDaemonTask,
+            conversationCount: this.conversationHistory.size,
+            daemonPhase: ((_b = (_a = this.daemon) === null || _a === void 0 ? void 0 : _a.getStatus()) === null || _b === void 0 ? void 0 : _b.phase) || null,
+        };
+    };
+    /**
+     * Cleanup resources
+     */
+    BaseChannel.prototype.cleanup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.daemon) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.daemon.stop()];
+                    case 1:
+                        _a.sent();
+                        this.daemon = null;
+                        _a.label = 2;
+                    case 2:
+                        this.conversationHistory.clear();
+                        this.activeDaemonTask = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Helper to create ChannelId for this channel
+     */
+    BaseChannel.prototype.createId = function () {
+        return (0, channel_types_1.createChannelId)(this.config.platform, this.config.accountId, this.config.instanceId);
+    };
+    return BaseChannel;
+}());
+exports.BaseChannel = BaseChannel;