@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Autonomous GLM 4.7 daemon with hooks, tools, teammates, and communication channels (Telegram, Discord)",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,11 +57,11 @@
     "status": "bun run dist/bin/manager.js status"
   },
   "dependencies": {
-    "@ebowwa/ai": "^0.1.0",
+    "@ebowwa/ai": "^0.1.2",
     "@ebowwa/channel-types": "^0.1.1",
-    "@ebowwa/codespaces-types": "^1.3.0",
-    "@ebowwa/structured-prompts": "^0.2.9",
-    "@ebowwa/teammates": "^0.1.0",
+    "@ebowwa/codespaces-types": "^1.4.0",
+    "@ebowwa/structured-prompts": "^0.3.2",
+    "@ebowwa/teammates": "^0.1.2",
     "discord.js": "^14.16.3",
     "node-telegram-bot-api": "^0.66.0",
     "zod": "^4.3.5"

package/src/agent.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * GLM Agent - Individual GLM-powered agent
+ *
+ * Wraps GLM 4.7 API with tool access and hook integration.
+ */
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLMAgent = void 0;
+var client_1 = require("@ebowwa/ai/client");
+var GLMAgent = /** @class */ (function () {
+    function GLMAgent(config) {
+        this.tools = new Map();
+        this.config = config;
+        this.client = new client_1.GLMClient();
+    }
+    /**
+     * Execute a prompt and get response
+     */
+    GLMAgent.prototype.execute = function (prompt, tools) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messages, response;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        messages = [
+                            {
+                                role: "system",
+                                content: this.config.prompt,
+                            },
+                            {
+                                role: "user",
+                                content: prompt,
+                            },
+                        ];
+                        // Add tool context if provided
+                        if (tools) {
+                            messages.push({
+                                role: "user",
+                                content: "\nAvailable tools: ".concat(Object.keys(tools).join(", ")),
+                            });
+                        }
+                        return [4 /*yield*/, this.client.chatCompletion(messages, {
+                                model: this.config.model || "glm-4.7",
+                                temperature: this.config.temperature || 0.7,
+                                maxTokens: this.config.maxTokens || 4096,
+                            })];
+                    case 1:
+                        response = _c.sent();
+                        return [2 /*return*/, ((_b = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content) || ""];
+                }
+            });
+        });
+    };
+    /**
+     * Execute a tool call
+     */
+    GLMAgent.prototype.executeTool = function (toolName, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, tool, result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        start = Date.now();
+                        tool = this.tools.get(toolName);
+                        if (!tool) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: "Tool not found: ".concat(toolName),
+                                    duration: Date.now() - start,
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, tool(args)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                result: result,
+                                duration: Date.now() - start,
+                            }];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_1 instanceof Error ? error_1.message : String(error_1),
+                                duration: Date.now() - start,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register a tool
+     */
+    GLMAgent.prototype.registerTool = function (name, handler) {
+        this.tools.set(name, handler);
+    };
+    /**
+     * Get available tools
+     */
+    GLMAgent.prototype.getAvailableTools = function () {
+        return Array.from(this.tools.keys());
+    };
+    Object.defineProperty(GLMAgent.prototype, "agentId", {
+        /**
+         * Get agent ID
+         */
+        get: function () {
+            return this.config.agentId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLMAgent.prototype, "name", {
+        /**
+         * Get agent name
+         */
+        get: function () {
+            return this.config.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return GLMAgent;
+}());
+exports.GLMAgent = GLMAgent;

package/src/builtin-tools.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * GLM Daemon - Built-in Tools
+ *
+ * Filesystem, shell, git, and system tools for GLM agents.
+ * These tools are available to all GLM daemon instances.
+ */
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_TOOLS = void 0;
+exports.getBuiltinTool = getBuiltinTool;
+exports.getBuiltinToolNames = getBuiltinToolNames;
+exports.toGLMFormat = toGLMFormat;
+exports.executeBuiltinTool = executeBuiltinTool;
+var child_process_1 = require("child_process");
+var fs_1 = require("fs");
+var structured_prompts_1 = require("@ebowwa/structured-prompts");
+/**
+ * All built-in tools available to GLM daemon
+ */
+exports.BUILTIN_TOOLS = [
+    {
+        name: 'read_file',
+        description: 'Read a file from the filesystem. Use for checking configs, logs, code.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path to read' }
+            },
+            required: ['path']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var path, content;
+            return __generator(this, function (_a) {
+                path = args.path;
+                try {
+                    if (!(0, fs_1.existsSync)(path))
+                        return [2 /*return*/, "File not found: ".concat(path)];
+                    content = (0, fs_1.readFileSync)(path, 'utf-8');
+                    return [2 /*return*/, content.length > 4000 ? content.slice(0, 4000) + '\n...[truncated]' : content];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error reading file: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'write_file',
+        description: 'Write content to a file. Creates the file if it does not exist, overwrites if it does.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path to write' },
+                content: { type: 'string', description: 'Content to write to the file' }
+            },
+            required: ['path', 'content']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var path, content;
+            return __generator(this, function (_a) {
+                path = args.path;
+                content = args.content;
+                try {
+                    (0, fs_1.writeFileSync)(path, content, 'utf-8');
+                    return [2 /*return*/, "Successfully wrote ".concat(content.length, " bytes to ").concat(path)];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error writing file: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'edit_file',
+        description: 'Edit a file by replacing a specific string with new content.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path to edit' },
+                old_string: { type: 'string', description: 'The exact text to find and replace' },
+                new_string: { type: 'string', description: 'The text to replace it with' }
+            },
+            required: ['path', 'old_string', 'new_string']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var path, oldStr, newStr, content, newContent;
+            return __generator(this, function (_a) {
+                path = args.path;
+                oldStr = args.old_string;
+                newStr = args.new_string;
+                try {
+                    if (!(0, fs_1.existsSync)(path))
+                        return [2 /*return*/, "File not found: ".concat(path)];
+                    content = (0, fs_1.readFileSync)(path, 'utf-8');
+                    if (!content.includes(oldStr)) {
+                        return [2 /*return*/, "String not found in file. First 500 chars:\n".concat(content.slice(0, 500))];
+                    }
+                    newContent = content.replace(oldStr, newStr);
+                    (0, fs_1.writeFileSync)(path, newContent, 'utf-8');
+                    return [2 /*return*/, "Successfully edited ".concat(path)];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error editing file: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'append_file',
+        description: 'Append content to the end of a file. Creates the file if it does not exist.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path to append to' },
+                content: { type: 'string', description: 'Content to append to the file' }
+            },
+            required: ['path', 'content']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var path, content;
+            return __generator(this, function (_a) {
+                path = args.path;
+                content = args.content;
+                try {
+                    (0, fs_1.appendFileSync)(path, content, 'utf-8');
+                    return [2 /*return*/, "Successfully appended ".concat(content.length, " bytes to ").concat(path)];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error appending to file: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'list_dir',
+        description: 'List contents of a directory. Shows files and subdirectories.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path to list (default: current working directory)' }
+            }
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var path, items;
+            return __generator(this, function (_a) {
+                path = args.path || process.cwd();
+                try {
+                    items = (0, child_process_1.execSync)("ls -la \"".concat(path, "\" 2>&1")).toString();
+                    return [2 /*return*/, items];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error listing directory: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'run_command',
+        description: 'Execute a shell command. Use for git, system info, etc. BE CAREFUL with destructive commands.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory (optional)' }
+            },
+            required: ['command']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var cmd, cwd, blocked, result;
+            var _a;
+            return __generator(this, function (_b) {
+                cmd = args.command;
+                cwd = args.cwd || process.cwd();
+                blocked = ['rm -rf', 'mkfs', 'dd if=', '> /dev/', 'chmod 777'];
+                if (blocked.some(function (b) { return cmd.includes(b); })) {
+                    return [2 /*return*/, "Blocked: command contains dangerous pattern"]; // TODO: AI SHOULD REREVIEW ALL AT THIS POINT, YES WE DO WANT AT TIME BUT WE NEED CAUTION AND RESTRAINT AND COMPLETE UNDERSTANDING
+                }
+                try {
+                    result = (0, child_process_1.execSync)(cmd, { timeout: 10000, cwd: cwd }).toString();
+                    return [2 /*return*/, result || '(no output)'];
+                }
+                catch (e) {
+                    return [2 /*return*/, ((_a = e.stdout) === null || _a === void 0 ? void 0 : _a.toString()) || e.message];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'git_status',
+        description: 'Check git repository status',
+        parameters: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Repository path (optional)' }
+            }
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var cwd, status_1, branch;
+            return __generator(this, function (_a) {
+                cwd = args.cwd || process.cwd();
+                try {
+                    status_1 = (0, child_process_1.execSync)('git status 2>&1', { cwd: cwd }).toString();
+                    branch = (0, child_process_1.execSync)('git branch --show-current 2>&1', { cwd: cwd }).toString();
+                    return [2 /*return*/, "Branch: ".concat(branch, "\n\n").concat(status_1)];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    },
+    {
+        name: 'get_prompt',
+        description: 'Get a prompt template from the prompt store',
+        parameters: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Prompt ID to retrieve' }
+            },
+            required: ['id']
+        },
+        handler: function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, prompt;
+            return __generator(this, function (_a) {
+                store = (0, structured_prompts_1.getStore)(process.env.PROMPTS_FILE);
+                prompt = store.get(args.id);
+                return [2 /*return*/, prompt ? JSON.stringify(prompt, null, 2) : "Prompt not found: ".concat(args.id)];
+            });
+        }); }
+    },
+    {
+        name: 'list_prompts',
+        description: 'List all available prompt templates',
+        parameters: { type: 'object', properties: {} },
+        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var store, prompts;
+            return __generator(this, function (_a) {
+                store = (0, structured_prompts_1.getStore)(process.env.PROMPTS_FILE);
+                prompts = store.list();
+                return [2 /*return*/, prompts.map(function (p) { return "- ".concat(p.id, ": ").concat(p.name); }).join('\n') || 'No prompts found'];
+            });
+        }); }
+    },
+    {
+        name: 'system_info',
+        description: 'Get system resource info (CPU, memory, disk, uptime)',
+        parameters: { type: 'object', properties: {} },
+        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var cpu, mem, disk, uptime;
+            return __generator(this, function (_a) {
+                try {
+                    cpu = (0, child_process_1.execSync)('nproc 2>/dev/null || echo "unknown"').toString().trim();
+                    mem = (0, child_process_1.execSync)('free -h 2>/dev/null | grep Mem || echo "unknown"').toString().trim();
+                    disk = (0, child_process_1.execSync)('df -h / 2>/dev/null | tail -1 || echo "unknown"').toString().trim();
+                    uptime = (0, child_process_1.execSync)('uptime -p 2>/dev/null || uptime 2>/dev/null || echo "unknown"').toString().trim();
+                    return [2 /*return*/, "CPU cores: ".concat(cpu, "\nMemory: ").concat(mem, "\nDisk: ").concat(disk, "\nUptime: ").concat(uptime)];
+                }
+                catch (e) {
+                    return [2 /*return*/, "Error: ".concat(e.message)];
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    }
+];
+/**
+ * Get tool by name
+ */
+function getBuiltinTool(name) {
+    return exports.BUILTIN_TOOLS.find(function (t) { return t.name === name; });
+}
+/**
+ * Get all tool names
+ */
+function getBuiltinToolNames() {
+    return exports.BUILTIN_TOOLS.map(function (t) { return t.name; });
+}
+/**
+ * Convert builtin tools to GLM API format
+ */
+function toGLMFormat(tools) {
+    if (tools === void 0) { tools = exports.BUILTIN_TOOLS; }
+    return tools.map(function (t) { return ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+        }
+    }); });
+}
+/**
+ * Execute a builtin tool by name
+ */
+function executeBuiltinTool(name, args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tool;
+        return __generator(this, function (_a) {
+            tool = getBuiltinTool(name);
+            if (!tool) {
+                return [2 /*return*/, "Unknown tool: ".concat(name)];
+            }
+            return [2 /*return*/, tool.handler(args)];
+        });
+    });
+}