@ebowwa/glm-daemon 0.1.0

package/src/tools.ts

@@ -0,0 +1,134 @@
+/**
+ * GLM Daemon - Tool Bridge
+ *
+ * Connects GLM agents to MCP servers for tool access.
+ */
+
+import type { GLMToolsConfig } from "./types.js";
+
+export class ToolBridge {
+  private config: GLMToolsConfig;
+  private availableTools: string[] = [];
+  private toolTimeout: number;
+  private maxRetries: number;
+
+  constructor(config: GLMToolsConfig = {}) {
+    this.config = config;
+    this.toolTimeout = config.toolTimeout || 30000;
+    this.maxRetries = config.maxRetries || 3;
+  }
+
+  /**
+   * Get list of available tools
+   */
+  getAvailableTools(): string[] {
+    return this.availableTools;
+  }
+
+  /**
+   * Set available tools (from MCP discovery)
+   */
+  setAvailableTools(tools: string[]): void {
+    this.availableTools = tools;
+  }
+
+  /**
+   * Check if a tool is allowed
+   */
+  isToolAllowed(toolName: string): boolean {
+    // Check blacklist first
+    if (this.config.blockedTools?.includes(toolName)) {
+      return false;
+    }
+
+    // If whitelist exists, check it
+    if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+      return this.config.allowedTools.includes(toolName);
+    }
+
+    // Default: allow if not blocked
+    return true;
+  }
+
+  /**
+   * Execute a tool with timeout and retry
+   */
+  async executeTool(
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<{ success: boolean; result?: unknown; error?: string }> {
+    if (!this.isToolAllowed(toolName)) {
+      return {
+        success: false,
+        error: `Tool not allowed: ${toolName}`,
+      };
+    }
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const result = await this.executeWithTimeout(toolName, args);
+        return { success: true, result };
+      } catch (error) {
+        lastError = error as Error;
+        // Wait before retry (exponential backoff)
+        if (attempt < this.maxRetries - 1) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, Math.pow(2, attempt) * 1000)
+          );
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError?.message || "Unknown error",
+    };
+  }
+
+  /**
+   * Execute tool with timeout
+   */
+  private async executeWithTimeout(
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Tool timeout: ${toolName}`));
+      }, this.toolTimeout);
+
+      // TODO: Actually call MCP tool here
+      // For now, this is a placeholder
+      setTimeout(() => {
+        clearTimeout(timer);
+        resolve(`Executed ${toolName} with ${JSON.stringify(args)}`);
+      }, 100);
+    });
+  }
+
+  /**
+   * Discover tools from MCP servers
+   */
+  async discoverMCPTools(): Promise<void> {
+    if (!this.config.enableMCP) {
+      return;
+    }
+
+    // TODO: Query MCP servers for available tools
+    // For now, add common tools
+    const commonTools = [
+      "Read",
+      "Write",
+      "Edit",
+      "Grep",
+      "Glob",
+      "Bash",
+      "git_status",
+      "git_commit",
+    ];
+
+    this.setAvailableTools(commonTools);
+  }
+}

package/src/types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * GLM Daemon - Core Types
+ *
+ * Autonomous AI daemon powered by GLM 4.7 with hooks, tools, and teammates.
+ * Based on Ralph Iterative's SLAM pattern (State → Loop → Action → Memory).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLM_PHASES = void 0;
+/**
+ * GLM Daemon state phases (SLAM pattern)
+ */
+exports.GLM_PHASES = {
+    planning: "planning",
+    executing: "executing",
+    paranoid: "paranoid",
+    reviewing: "reviewing",
+    fixing: "fixing",
+    committing: "committing",
+    complete: "complete",
+};

package/src/types.ts

@@ -0,0 +1,249 @@
+/**
+ * GLM Daemon - Core Types
+ *
+ * Autonomous AI daemon powered by GLM 4.7 with hooks, tools, and teammates.
+ * Based on Ralph Iterative's SLAM pattern (State → Loop → Action → Memory).
+ */
+
+import type { Team } from "@ebowwa/teammates";
+
+/**
+ * GLM Daemon state phases (SLAM pattern)
+ */
+export const GLM_PHASES = {
+  planning: "planning",
+  executing: "executing",
+  paranoid: "paranoid",
+  reviewing: "reviewing",
+  fixing: "fixing",
+  committing: "committing",
+  complete: "complete",
+} as const;
+
+export type GLMPhase = keyof typeof GLM_PHASES;
+
+/**
+ * GLM Daemon configuration
+ */
+export interface GLMDaemonConfig {
+  /** Team name for multi-agent coordination */
+  teamName: string;
+
+  /** GLM model to use */
+  model?: string;
+
+  /** Working directory */
+  cwd: string;
+
+  /** Enable git worktree isolation */
+  enableWorktree?: boolean;
+
+  /** Enable automatic commits */
+  autoCommit?: boolean;
+
+  /** Enable automatic PR creation */
+  autoPR?: boolean;
+
+  /** Base branch for PRs */
+  baseBranch?: string;
+
+  /** Maximum iterations (0 = unlimited) */
+  maxIterations?: number;
+
+  /** Completion promise text */
+  completionPromise?: string;
+
+  /** Hooks configuration */
+  hooks?: GLMHooksConfig;
+
+  /** Tools configuration */
+  tools?: GLMToolsConfig;
+}
+
+/**
+ * GLM Daemon state (persisted to disk)
+ */
+export interface GLMDaemonState {
+  /** Original prompt/task */
+  prompt: string;
+
+  /** Completion promise (when to stop) */
+  promise: string;
+
+  /** Current iteration */
+  iteration: number;
+
+  /** Maximum iterations */
+  maxIterations: number;
+
+  /** Start timestamp */
+  startTime: string;
+
+  /** Last update timestamp */
+  lastUpdate: string;
+
+  /** Token usage tracking */
+  tokens: {
+    totalInput: number;
+    totalOutput: number;
+    byIteration: Array<{
+      iteration: number;
+      input: number;
+      output: number;
+    }>;
+  };
+
+  /** Files changed in this session */
+  filesChanged: string[];
+
+  /** Working memory */
+  workMemory: {
+    completedFiles: string[];
+    fileChecksums: Record<string, string>;
+  };
+
+  /** SLAM state */
+  slam: {
+    enabled: boolean;
+    phase: GLMPhase;
+    state: {
+      currentTask: string;
+      beliefs: Record<string, unknown>;
+      goals: string[];
+    };
+    subtasks: GLMSubtask[];
+    currentSubtask: string | null;
+    completedSubtasks: string[];
+    memory: {
+      actionsTaken: string[];
+      outcomes: Record<string, unknown>;
+      patterns: Record<string, unknown>;
+    };
+  };
+
+  /** Git configuration */
+  git: {
+    enabled: boolean;
+    autoCommit: boolean;
+    autoPR: boolean;
+    baseBranch: string;
+    useWorktree: boolean;
+    branchName: string;
+    branchCreated: boolean;
+    currentCommit: string;
+  };
+
+  /** Machine info */
+  machine?: {
+    cpu: { count: number; model: string; tier: string };
+    memory: { total: number; free: number; tier: string };
+    disk: { total: number; available: number; tier: string };
+    platform: { os: string; arch: string; isContainer: boolean };
+    capacity: string;
+    score: number;
+  };
+}
+
+/**
+ * GLM Subtask (for SLAM coordination)
+ */
+export interface GLMSubtask {
+  id: string;
+  title: string;
+  description: string;
+  status: "pending" | "in_progress" | "completed" | "blocked" | "failed";
+  assignedTo?: string;
+  dependencies?: string[];
+  result?: unknown;
+}
+
+/**
+ * GLM Hooks configuration
+ */
+export interface GLMHooksConfig {
+  onSessionStart?: (state: GLMDaemonState) => Promise<void>;
+  onSessionEnd?: (state: GLMDaemonState) => Promise<void>;
+  onPreToolUse?: (tool: string, args: unknown) => Promise<boolean>;
+  onPostToolUse?: (tool: string, args: unknown, result: unknown) => Promise<void>;
+  onSubagentStart?: (subagentId: string) => Promise<void>;
+  onSubagentStop?: (subagentId: string, result: unknown) => Promise<void>;
+  onIterationStart?: (iteration: number) => Promise<void>;
+  onIterationEnd?: (iteration: number, result: unknown) => Promise<void>;
+}
+
+/**
+ * GLM Tools configuration
+ */
+export interface GLMToolsConfig {
+  /** Enable MCP tool access */
+  enableMCP?: boolean;
+
+  /** Allowed tools (whitelist) */
+  allowedTools?: string[];
+
+  /** Blocked tools (blacklist) */
+  blockedTools?: string[];
+
+  /** Tool timeout in ms */
+  toolTimeout?: number;
+
+  /** Max retries for failed tools */
+  maxRetries?: number;
+}
+
+/**
+ * GLM Agent (individual GLM-powered agent)
+ */
+export interface GLMAgentConfig {
+  /** Agent ID */
+  agentId: string;
+
+  /** Agent name */
+  name: string;
+
+  /** System prompt */
+  prompt: string;
+
+  /** Model to use */
+  model?: string;
+
+  /** Temperature (0-1) */
+  temperature?: number;
+
+  /** Max tokens */
+  maxTokens?: number;
+
+  /** Tools this agent can use */
+  tools?: string[];
+
+  /** Assigned subtasks */
+  assignedSubtasks?: string[];
+}
+
+/**
+ * GLM Tool execution result
+ */
+export interface GLMToolResult {
+  success: boolean;
+  result?: unknown;
+  error?: string;
+  duration: number;
+}
+
+/**
+ * GLM Daemon status
+ */
+export interface GLMDaemonStatus {
+  id: string;
+  status: "starting" | "running" | "complete" | "error" | "stopped";
+  phase: GLMPhase;
+  iteration: number;
+  prompt: string;
+  currentTask?: string;
+  totalSubtasks: number;
+  completedSubtasks: number;
+  startedAt: string;
+  lastUpdate: string;
+  processId?: number;
+  worktreePath?: string;
+}

package/src/worktree.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * GLM Daemon - Worktree Manager
+ *
+ * Handles git worktree isolation for parallel task execution.
+ */
+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.WorktreeManager = void 0;
+var child_process_1 = require("child_process");
+var util_1 = require("util");
+var path_1 = require("path");
+var execAsync = (0, util_1.promisify)(child_process_1.exec);
+var WorktreeManager = /** @class */ (function () {
+    function WorktreeManager(config) {
+        this.worktreePath = null;
+        this.config = config;
+    }
+    /**
+     * Create a new worktree for isolation
+     */
+    WorktreeManager.prototype.createWorktree = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var timestamp, worktreeName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.enableWorktree) {
+                            return [2 /*return*/, this.config.cwd];
+                        }
+                        timestamp = Date.now();
+                        worktreeName = "glm-".concat(timestamp);
+                        this.worktreePath = (0, path_1.join)(this.config.cwd, "worktrees", worktreeName);
+                        // Create worktrees directory
+                        return [4 /*yield*/, execAsync("mkdir -p ".concat((0, path_1.join)(this.config.cwd, "worktrees")))];
+                    case 1:
+                        // Create worktrees directory
+                        _a.sent();
+                        // Create worktree
+                        return [4 /*yield*/, execAsync("git worktree add -b ".concat(worktreeName, " ").concat(this.worktreePath))];
+                    case 2:
+                        // Create worktree
+                        _a.sent();
+                        return [2 /*return*/, this.worktreePath];
+                }
+            });
+        });
+    };
+    /**
+     * Create a feature branch in the worktree
+     */
+    WorktreeManager.prototype.createBranch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var branchName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.worktreePath) {
+                            throw new Error("No worktree created");
+                        }
+                        branchName = "feat/glm-".concat(Date.now());
+                        return [4 /*yield*/, execAsync("cd ".concat(this.worktreePath, " && git checkout -b ").concat(branchName))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, branchName];
+                }
+            });
+        });
+    };
+    /**
+     * Commit changes in the worktree
+     */
+    WorktreeManager.prototype.commitChanges = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cwd, _i, _a, file, stdout;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        cwd = this.worktreePath || this.config.cwd;
+                        _i = 0, _a = options.files;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        file = _a[_i];
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git add ").concat(file))];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git commit -m \"").concat(options.message, "\""))];
+                    case 5:
+                        stdout = (_b.sent()).stdout;
+                        return [2 /*return*/, stdout.trim()];
+                }
+            });
+        });
+    };
+    /**
+     * Create a pull request
+     */
+    WorktreeManager.prototype.createPullRequest = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cwd;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cwd = this.worktreePath || this.config.cwd;
+                        // Push branch
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git push -u origin HEAD"))];
+                    case 1:
+                        // Push branch
+                        _a.sent();
+                        // Create PR using gh CLI
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && gh pr create --title \"").concat(options.title, "\" --body \"").concat(options.body, "\""))];
+                    case 2:
+                        // Create PR using gh CLI
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clean up worktree
+     */
+    WorktreeManager.prototype.cleanup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.worktreePath) {
+                            return [2 /*return*/];
+                        }
+                        // Remove worktree
+                        return [4 /*yield*/, execAsync("git worktree remove ".concat(this.worktreePath))];
+                    case 1:
+                        // Remove worktree
+                        _a.sent();
+                        // Delete directory
+                        return [4 /*yield*/, execAsync("rm -rf ".concat(this.worktreePath))];
+                    case 2:
+                        // Delete directory
+                        _a.sent();
+                        this.worktreePath = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get worktree path
+     */
+    WorktreeManager.prototype.getPath = function () {
+        return this.worktreePath;
+    };
+    return WorktreeManager;
+}());
+exports.WorktreeManager = WorktreeManager;