@ebowwa/daemons 0.5.0

package/src/index.ts

@@ -0,0 +1,111 @@
+/**
+ * Daemons - Autonomous Agent Daemon Framework
+ *
+ * A daemon framework for autonomous AI agents.
+ * Implements SLAM pattern (State → Loop → Action → Memory).
+ * Supports hooks, tools via MCP, multi-agent coordination, and communication channels.
+ *
+ * @module @ebowwa/daemons
+ */
+
+// Main daemon class
+export { GLMDaemon, type GLMDaemonConfigWithWorkflow } from "./daemon.js";
+
+// Agent class
+export { GLMAgent } from "./agent.js";
+
+// Supporting systems
+export { HookSystem } from "./hooks.js";
+export { ToolBridge } from "./tools.js";
+export { StateManager } from "./state.js";
+
+// Workflow system
+export {
+  // Classes
+  BaseWorkflow,
+  WorkflowRegistry,
+  workflowRegistry,
+  // Functions
+  initializeWorkflows,
+  getWorkflow,
+  getDefaultWorkflow,
+  // Built-in workflows
+  CodingWorkflow,
+  codingWorkflow,
+  CODING_PHASES,
+  CODING_TRANSITIONS,
+  CODING_WORKFLOW_CONFIG,
+  TradingWorkflow,
+  tradingWorkflow,
+  TRADING_PHASES,
+  TRADING_TRANSITIONS,
+  TRADING_WORKFLOW_CONFIG,
+  // Types
+  type GLMWorkflowPhase,
+  type GLMWorkflowContext,
+  type GLMWorkflowPhaseResult,
+  type GLMWorkflowTransition,
+  type GLMWorkflowConfig,
+  type GLMWorkflowExecutor,
+  type CodingPhase,
+  type TradingPhase,
+} from "./workflows/index.js";
+
+// Built-in tools - re-exported from @ebowwa/ai/tools for convenience
+export {
+  BUILTIN_TOOLS,
+  getBuiltinTool,
+  getBuiltinToolNames,
+  toGLMFormat,
+  executeBuiltinTool,
+  ToolExecutor,
+  type ToolDefinition,
+  type ToolCall,
+  type ToolExecutorOptions,
+  type ToolExecutionResult,
+} from "@ebowwa/ai/tools";
+
+// Memory systems
+export {
+  ConversationMemory,
+  NumericConversationMemory,
+  StringConversationMemory,
+  type ConversationMessage,
+  type ConversationMemoryConfig,
+} from "./memory.js";
+
+// Communication channels
+export {
+  BaseChannel,
+  TelegramChannel,
+  DiscordChannel,
+  ChannelRegistry,
+  type BaseChannelConfig,
+  type TelegramChannelConfig,
+  type DiscordChannelConfig,
+  type MessageContext,
+  type RouteResult,
+  type MessageClassification,
+} from "./channels/index.js";
+
+// Types
+export * from "./types.js";
+
+// Convenience function to create and start a daemon
+import { GLMDaemon } from "./daemon.js";
+import type { GLMDaemonConfig } from "./types.js";
+
+export async function createGLMDaemon(
+  config: GLMDaemonConfig
+): Promise<GLMDaemon> {
+  const daemon = new GLMDaemon(config);
+  return daemon;
+}
+
+export async function startGLMDaemon(
+  config: GLMDaemonConfig,
+  prompt: string
+): Promise<string> {
+  const daemon = new GLMDaemon(config);
+  return await daemon.start(prompt);
+}

package/src/memory.ts

@@ -0,0 +1,369 @@
+/**
+ * Conversation Memory - Generic conversation tracking for any channel
+ *
+ * Tracks chat history per user/conversation with persistence.
+ * Can be used by Telegram, Discord, or any other channel.
+ *
+ * Storage format: JSONL (JSON Lines)
+ * Each line is a JSON object: {"id": "...", "messages": [...], "lastUpdated": timestamp}
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+} from "fs";
+import { dirname } from "path";
+
+/**
+ * A single message in a conversation
+ */
+export interface ConversationMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+  timestamp?: number;
+}
+
+/**
+ * Internal storage format for JSONL
+ */
+interface ConversationEntry {
+  id: string;
+  messages: ConversationMessage[];
+  lastUpdated: number;
+}
+
+/**
+ * Configuration for ConversationMemory
+ */
+export interface ConversationMemoryConfig {
+  /** Path to persistence file (default: ./conversations.jsonl) */
+  file?: string;
+  /** Maximum messages to keep per conversation (default: 10) */
+  maxMessages?: number;
+  /** Include timestamps in messages (default: true) */
+  includeTimestamps?: boolean;
+  /** Auto-migrate old .json files to .jsonl (default: true) */
+  autoMigrate?: boolean;
+}
+
+/**
+ * Generic conversation memory that tracks chat history per conversation ID.
+ *
+ * Uses JSONL format for efficient append-only writes and streaming reads.
+ * Automatically migrates from old JSON format on first load.
+ *
+ * The ID type is generic (string | number) to support different channel types:
+ * - Telegram: number (chatId)
+ * - Discord: string (channelId/userId)
+ * - Slack: string (channelId)
+ *
+ * @example
+ * ```ts
+ * const memory = new ConversationMemory({ maxMessages: 20 });
+ * memory.add(12345, 'user', 'Hello!');
+ * memory.add(12345, 'assistant', 'Hi there!');
+ * const history = memory.get(12345);
+ * ```
+ */
+export class ConversationMemory<IdType = string | number> {
+  private conversations = new Map<IdType, ConversationMessage[]>();
+  private maxMessages: number;
+  private includeTimestamps: boolean;
+  private file: string;
+  private needsFullSave = false;
+
+  constructor(config: ConversationMemoryConfig = {}) {
+    // Default to .jsonl extension
+    const defaultFile = "./conversations.jsonl";
+    this.file = config.file || defaultFile;
+
+    // Auto-migrate from .json to .jsonl if needed
+    if (config.autoMigrate !== false && !existsSync(this.file)) {
+      this.migrateFromJson(this.file);
+    }
+
+    this.maxMessages = config.maxMessages ?? 10;
+    this.includeTimestamps = config.includeTimestamps ?? true;
+    this.load();
+  }
+
+  /**
+   * Migrate from old JSON format to JSONL
+   */
+  private migrateFromJson(jsonlFile: string): void {
+    // Check for old .json file
+    const jsonFile = jsonlFile.replace(/\.jsonl$/, ".json");
+    if (!existsSync(jsonFile)) return;
+
+    try {
+      const data = JSON.parse(readFileSync(jsonFile, "utf-8"));
+      const entries: ConversationEntry[] = [];
+
+      for (const [id, messages] of Object.entries(data)) {
+        entries.push({
+          id,
+          messages: messages as ConversationMessage[],
+          lastUpdated: Date.now(),
+        });
+      }
+
+      // Write as JSONL
+      const dir = dirname(jsonlFile);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const lines = entries.map((e) => JSON.stringify(e)).join("\n");
+      writeFileSync(jsonlFile, lines + (lines ? "\n" : ""));
+
+      // Backup old file instead of deleting
+      const backupFile = jsonFile + ".backup";
+      renameSync(jsonFile, backupFile);
+
+      console.log(`Migrated ${jsonFile} to ${jsonlFile} (${entries.length} conversations)`);
+    } catch (error) {
+      console.error(`Migration failed: ${error}`);
+    }
+  }
+
+  /**
+   * Load conversations from JSONL file
+   * Uses synchronous read for constructor compatibility
+   */
+  private load(): void {
+    if (!existsSync(this.file)) return;
+
+    try {
+      const content = readFileSync(this.file, "utf-8");
+      const lines = content.split("\n");
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry: ConversationEntry = JSON.parse(line);
+          const key = this.parseKey(entry.id);
+          this.conversations.set(key, entry.messages);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    } catch {
+      // Start fresh on error
+    }
+  }
+
+  /**
+   * Parse string key back to original type
+   */
+  private parseKey(id: string): IdType {
+    // Try to parse as number if it looks like one
+    if (/^-?\d+$/.test(id)) {
+      return Number(id) as IdType;
+    }
+    return id as IdType;
+  }
+
+  /**
+   * Convert IdType to string for storage
+   */
+  private stringifyKey(id: IdType): string {
+    return String(id);
+  }
+
+  /**
+   * Save all conversations to disk (full rewrite)
+   * Used when entries are deleted or modified
+   */
+  private saveFull(): void {
+    try {
+      const dir = dirname(this.file);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const lines: string[] = [];
+      for (const [id, messages] of this.conversations) {
+        const entry: ConversationEntry = {
+          id: this.stringifyKey(id),
+          messages,
+          lastUpdated: Date.now(),
+        };
+        lines.push(JSON.stringify(entry));
+      }
+
+      writeFileSync(this.file, lines.join("\n") + (lines.length ? "\n" : ""));
+      this.needsFullSave = false;
+    } catch (error) {
+      console.error(`Save failed: ${error}`);
+    }
+  }
+
+  /**
+   * Append a single entry to the file (efficient for adds)
+   */
+  private appendEntry(conversationId: IdType, messages: ConversationMessage[]): void {
+    try {
+      const dir = dirname(this.file);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const entry: ConversationEntry = {
+        id: this.stringifyKey(conversationId),
+        messages,
+        lastUpdated: Date.now(),
+      };
+
+      // Check if file exists and has content to determine if we need newline
+      const hasContent = existsSync(this.file) && readFileSync(this.file, "utf-8").length > 0;
+      const prefix = hasContent ? "" : "";
+      const line = JSON.stringify(entry) + "\n";
+
+      // We need to do a full save to replace the old entry for this conversation
+      // JSONL doesn't support in-place updates, so we mark for full save
+      this.needsFullSave = true;
+
+      // For now, do a full save since we need to replace the entry
+      this.saveFull();
+    } catch (error) {
+      console.error(`Append failed: ${error}`);
+    }
+  }
+
+  /**
+   * Add a message to a conversation
+   */
+  add(
+    conversationId: IdType,
+    role: "user" | "assistant" | "system",
+    content: string
+  ): void {
+    if (!this.conversations.has(conversationId)) {
+      this.conversations.set(conversationId, []);
+    }
+
+    const history = this.conversations.get(conversationId)!;
+    const message: ConversationMessage = { role, content };
+
+    if (this.includeTimestamps) {
+      message.timestamp = Date.now();
+    }
+
+    history.push(message);
+
+    // Keep only last N messages
+    if (history.length > this.maxMessages) {
+      history.splice(0, history.length - this.maxMessages);
+    }
+
+    // Save the updated conversation
+    this.appendEntry(conversationId, history);
+  }
+
+  /**
+   * Get conversation history for a specific conversation
+   */
+  get(conversationId: IdType): ConversationMessage[] {
+    return this.conversations.get(conversationId) || [];
+  }
+
+  /**
+   * Get all conversations
+   */
+  getAll(): Map<IdType, ConversationMessage[]> {
+    return new Map(this.conversations);
+  }
+
+  /**
+   * Clear a specific conversation
+   */
+  clear(conversationId: IdType): void {
+    this.conversations.delete(conversationId);
+    this.saveFull();
+  }
+
+  /**
+   * Clear all conversations
+   */
+  clearAll(): void {
+    this.conversations.clear();
+    this.saveFull();
+  }
+
+  /**
+   * Check if a conversation exists
+   */
+  has(conversationId: IdType): boolean {
+    return this.conversations.has(conversationId);
+  }
+
+  /**
+   * Get the number of conversations
+   */
+  size(): number {
+    return this.conversations.size;
+  }
+
+  /**
+   * Get the messages count for a specific conversation
+   */
+  messageCount(conversationId: IdType): number {
+    return this.conversations.get(conversationId)?.length || 0;
+  }
+
+  /**
+   * Get formatted history for API calls (OpenAI/Anthropic format)
+   */
+  getForAPI(
+    conversationId: IdType
+  ): Array<{ role: string; content: string }> {
+    return this.get(conversationId).map(({ role, content }) => ({
+      role,
+      content,
+    }));
+  }
+
+  /**
+   * Force a full save (useful before shutdown)
+   */
+  flush(): void {
+    if (this.needsFullSave || this.conversations.size > 0) {
+      this.saveFull();
+    }
+  }
+
+  /**
+   * Get the file path being used
+   */
+  getFilePath(): string {
+    return this.file;
+  }
+
+  /**
+   * Check if the storage uses JSONL format
+   */
+  isJsonl(): boolean {
+    return this.file.endsWith(".jsonl");
+  }
+}
+
+/**
+ * Pre-configured memory for numeric IDs (like Telegram chat IDs)
+ */
+export class NumericConversationMemory extends ConversationMemory<number> {
+  constructor(config: Omit<ConversationMemoryConfig, "file"> & { file?: string } = {}) {
+    super(config);
+  }
+}
+
+/**
+ * Pre-configured memory for string IDs (like Discord/Slack channel IDs)
+ */
+export class StringConversationMemory extends ConversationMemory<string> {
+  constructor(config: Omit<ConversationMemoryConfig, "file"> & { file?: string } = {}) {
+    super(config);
+  }
+}

package/src/skills/coding/commit.ts

@@ -0,0 +1,202 @@
+/**
+ * GLM Daemon - Commit Skill
+ *
+ * Commit changes to git with auto-generated message.
+ */
+
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+const execAsync = promisify(exec);
+
+/**
+ * Commit parameters
+ */
+const CommitParams = z.object({
+  /** Custom commit message */
+  message: z.string().optional(),
+  /** Whether to push after commit */
+  push: z.boolean().optional(),
+  /** Skip hooks */
+  noVerify: z.boolean().optional(),
+});
+
+/**
+ * Commit result data
+ */
+interface CommitData {
+  commitHash: string;
+  message: string;
+  filesCount: number;
+  pushed: boolean;
+}
+
+/**
+ * Commit skill
+ */
+export const commitSkill: Skill<z.infer<typeof CommitParams>, CommitData> = {
+  id: "/commit",
+  name: "Commit",
+  description: "Commit changes to git with an auto-generated or custom message.",
+  paramsSchema: CommitParams,
+  tags: ["coding", "git"],
+  parallelizable: false,
+
+  async execute(params, context): Promise<SkillResult<CommitData>> {
+    const filesCount = context.state.filesChanged.length;
+
+    if (filesCount === 0) {
+      console.log("[/commit] No files to commit");
+      return {
+        success: true,
+        data: {
+          commitHash: "",
+          message: "No changes to commit",
+          filesCount: 0,
+          pushed: false,
+        },
+        nextSkill: "/complete",
+      };
+    }
+
+    console.log(`[/commit] Committing ${filesCount} files`);
+
+    // Generate commit message if not provided
+    let message = params?.message;
+    if (!message) {
+      const prompt = `Generate a concise git commit message for these changes:
+
+Task: ${context.state.prompt}
+Files: ${context.state.filesChanged.join(", ")}
+
+Format: <type>: <description>
+
+Types: feat, fix, refactor, docs, test, chore
+
+Just output the commit message, nothing else.`;
+
+      const response = await context.agent.execute(prompt);
+      message = response.split("\n")[0].trim();
+    }
+
+    console.log(`[/commit] Message: ${message}`);
+
+    // Get the working directory from workflow config or use current directory
+    const cwd = (context.workflowConfig?.cwd as string) || process.cwd();
+    const pushed = params?.push ?? false;
+
+    try {
+      // Step 1: Stage all changed files
+      const filesToStage = context.state.filesChanged.length > 0
+        ? context.state.filesChanged.join(" ")
+        : "."; // Stage all if no specific files tracked
+
+      console.log(`[/commit] Staging files: ${filesToStage}`);
+      await execAsync(`git add ${filesToStage}`, { cwd });
+
+      // Step 2: Commit with message
+      const noVerifyFlag = params?.noVerify ? " --no-verify" : "";
+      const escapedMessage = message.replace(/"/g, '\\"');
+      const commitCommand = `git commit -m "${escapedMessage}"${noVerifyFlag}`;
+
+      console.log(`[/commit] Executing commit...`);
+      const { stdout: commitOutput } = await execAsync(commitCommand, { cwd });
+
+      // Extract commit hash from output (format: [main abc1234] message)
+      const hashMatch = commitOutput.match(/\[[\w-]+\s+([a-f0-9]+)\]/);
+      const commitHash = hashMatch ? hashMatch[1] : "";
+
+      if (!commitHash) {
+        console.warn("[/commit] Could not extract commit hash from output");
+      }
+
+      console.log(`[/commit] Committed: ${commitHash}`);
+
+      // Step 3: Push if requested
+      if (pushed) {
+        console.log(`[/commit] Pushing to remote...`);
+        try {
+          await execAsync("git push", { cwd });
+          console.log(`[/commit] Pushed successfully`);
+        } catch (pushError) {
+          console.error("[/commit] Push failed:", pushError);
+          // Don't fail the whole commit if push fails
+          return {
+            success: true,
+            data: {
+              commitHash,
+              message: message || "Changes committed",
+              filesCount,
+              pushed: false,
+            },
+            contextUpdates: {
+              lastCommit: commitHash,
+              lastCommitMessage: message,
+            },
+            stateUpdates: {
+              git: {
+                ...context.state.git,
+                currentCommit: commitHash,
+              },
+            },
+            nextSkill: "/complete",
+            error: `Commit succeeded but push failed: ${pushError instanceof Error ? pushError.message : String(pushError)}`,
+          };
+        }
+      }
+
+      return {
+        success: true,
+        data: {
+          commitHash,
+          message: message || "Changes committed",
+          filesCount,
+          pushed,
+        },
+        contextUpdates: {
+          lastCommit: commitHash,
+          lastCommitMessage: message,
+        },
+        stateUpdates: {
+          git: {
+            ...context.state.git,
+            currentCommit: commitHash,
+          },
+        },
+        nextSkill: "/complete",
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("[/commit] Git operation failed:", errorMessage);
+
+      // Check if it's just "nothing to commit"
+      if (errorMessage.includes("nothing to commit") || errorMessage.includes("no changes added to commit")) {
+        console.log("[/commit] No changes to commit (already clean)");
+        return {
+          success: true,
+          data: {
+            commitHash: context.state.git.currentCommit || "",
+            message: "No changes to commit",
+            filesCount: 0,
+            pushed: false,
+          },
+          nextSkill: "/complete",
+        };
+      }
+
+      return {
+        success: false,
+        error: `Git operation failed: ${errorMessage}`,
+        nextSkill: "/fix-issues",
+      };
+    }
+  },
+};
+
+skillRegistry.register(commitSkill);
+
+export { CommitParams };
+export type { CommitData };