@ebowwa/glm-daemon 0.1.0

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@ebowwa/glm-daemon",
+  "version": "0.1.0",
+  "description": "Autonomous GLM 4.7 daemon with hooks, tools, and teammates",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./daemon": {
+      "types": "./dist/daemon.d.ts",
+      "import": "./dist/daemon.js"
+    },
+    "./agent": {
+      "types": "./dist/agent.d.ts",
+      "import": "./dist/agent.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks.d.ts",
+      "import": "./dist/hooks.js"
+    },
+    "./tools": {
+      "types": "./dist/tools.d.ts",
+      "import": "./dist/tools.js"
+    },
+    "./state": {
+      "types": "./dist/state.d.ts",
+      "import": "./dist/state.js"
+    },
+    "./worktree": {
+      "types": "./dist/worktree.d.ts",
+      "import": "./dist/worktree.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:types": "tsc --emitDeclarationOnly",
+    "dev": "bun --watch src/index.ts",
+    "test": "bun test",
+    "lint": "eslint src --ext .ts",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@ebowwa/ai": "^0.1.0",
+    "@ebowwa/codespaces-types": "^1.1.0",
+    "@ebowwa/teammates": "^0.1.0",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@types/bun": "catalog:dev",
+    "@types/node": "catalog:dev",
+    "typescript": "catalog:",
+    "bun-types": "catalog:dev"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "glm",
+    "daemon",
+    "agent",
+    "autonomous",
+    "ai"
+  ]
+}

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("@codespaces/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;
+            return __generator(this, function (_a) {
+                switch (_a.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.chat({
+                                messages: messages,
+                                model: this.config.model || "glm-4.7",
+                                temperature: this.config.temperature || 0.7,
+                                maxTokens: this.config.maxTokens || 4096,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.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/agent.ts

@@ -0,0 +1,110 @@
+/**
+ * GLM Agent - Individual GLM-powered agent
+ *
+ * Wraps GLM 4.7 API with tool access and hook integration.
+ */
+
+import type { GLMAgentConfig, GLMToolResult } from "./types.js";
+import { GLMClient, type ChatMessage } from "@ebowwa/ai/client";
+
+export class GLMAgent {
+  private config: GLMAgentConfig;
+  private client: GLMClient;
+  private tools: Map<string, (args: unknown) => Promise<unknown>> = new Map();
+
+  constructor(config: GLMAgentConfig) {
+    this.config = config;
+    this.client = new GLMClient();
+  }
+
+  /**
+   * Execute a prompt and get response
+   */
+  async execute(prompt: string, tools?: Record<string, unknown>): Promise<string> {
+    const messages: ChatMessage[] = [
+      {
+        role: "system",
+        content: this.config.prompt,
+      },
+      {
+        role: "user",
+        content: prompt,
+      },
+    ];
+
+    // Add tool context if provided
+    if (tools) {
+      messages.push({
+        role: "user",
+        content: `\nAvailable tools: ${Object.keys(tools).join(", ")}`,
+      });
+    }
+
+    const response = await this.client.chatCompletion(messages, {
+      model: this.config.model || "glm-4.7",
+      temperature: this.config.temperature || 0.7,
+      maxTokens: this.config.maxTokens || 4096,
+    });
+
+    return response.choices[0]?.message?.content || "";
+  }
+
+  /**
+   * Execute a tool call
+   */
+  async executeTool(toolName: string, args: unknown): Promise<GLMToolResult> {
+    const start = Date.now();
+    const tool = this.tools.get(toolName);
+
+    if (!tool) {
+      return {
+        success: false,
+        error: `Tool not found: ${toolName}`,
+        duration: Date.now() - start,
+      };
+    }
+
+    try {
+      const result = await tool(args);
+      return {
+        success: true,
+        result,
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        duration: Date.now() - start,
+      };
+    }
+  }
+
+  /**
+   * Register a tool
+   */
+  registerTool(name: string, handler: (args: unknown) => Promise<unknown>): void {
+    this.tools.set(name, handler);
+  }
+
+  /**
+   * Get available tools
+   */
+  getAvailableTools(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  /**
+   * Get agent ID
+   */
+  get agentId(): string {
+    return this.config.agentId;
+  }
+
+  /**
+   * Get agent name
+   */
+  get name(): string {
+    return this.config.name;
+  }
+}