@ebowwa/daemons 0.5.1 → 0.7.0

package/src/memory.ts

@@ -1,369 +0,0 @@
-/**
- * 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

@@ -1,202 +0,0 @@
-/**
- * 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 };

package/src/skills/coding/execute-subtask.ts

@@ -1,136 +0,0 @@
-/**
- * GLM Daemon - Execute Subtask Skill
- *
- * Work on the current subtask from the plan.
- */
-
-import { z } from "zod";
-import type { Skill, SkillContext, SkillResult } from "../types.js";
-import { skillRegistry } from "../registry.js";
-import type { Subtask } from "./plan-task.js";
-
-/**
- * Execute subtask parameters
- */
-const ExecuteSubtaskParams = z.object({
-  /** Specific subtask ID to execute (defaults to current) */
-  subtaskId: z.string().optional(),
-});
-
-/**
- * Execute subtask result data
- */
-interface ExecuteSubtaskData {
-  subtaskId: string;
-  title: string;
-  result: string;
-  completed: boolean;
-  nextSubtaskId: string | null;
-}
-
-/**
- * Execute subtask skill
- */
-export const executeSubtaskSkill: Skill<z.infer<typeof ExecuteSubtaskParams>, ExecuteSubtaskData> = {
-  id: "/execute-subtask",
-  name: "Execute Subtask",
-  description: "Work on the current subtask using available tools.",
-  paramsSchema: ExecuteSubtaskParams,
-  tags: ["coding", "execution"],
-  parallelizable: false,
-  requires: ["subtasks"],
-
-  async execute(params, context): Promise<SkillResult<ExecuteSubtaskData>> {
-    // Get subtask to execute
-    const subtaskId = params?.subtaskId || context.state.slam.currentSubtask;
-
-    if (!subtaskId) {
-      console.log("[/execute-subtask] No current subtask, all complete");
-      return {
-        success: true,
-        data: {
-          subtaskId: "",
-          title: "",
-          result: "All subtasks complete",
-          completed: true,
-          nextSubtaskId: null,
-        },
-        nextSkill: "/quality-check",
-      };
-    }
-
-    const subtask = context.state.slam.subtasks.find((st) => st.id === subtaskId) as Subtask | undefined;
-
-    if (!subtask) {
-      return {
-        success: false,
-        error: `Subtask not found: ${subtaskId}`,
-      };
-    }
-
-    console.log(`[/execute-subtask] Working on: ${subtask.title}`);
-
-    const prompt = `Work on this subtask: ${subtask.title}
-
-${subtask.description}
-
-Use available tools to complete the work.
-Focus on making concrete progress.
-
-When done, briefly summarize what was accomplished.`;
-
-    try {
-      const result = await context.agent.execute(prompt);
-
-      // Mark subtask as completed
-      const completedSubtasks = [...new Set([...context.state.slam.completedSubtasks, subtaskId])];
-      const updatedSubtasks = context.state.slam.subtasks.map((st) =>
-        st.id === subtaskId ? { ...st, status: "completed" as const, result } : st
-      );
-
-      // Find next subtask (that isn't completed and has dependencies met)
-      const nextSubtask = context.state.slam.subtasks.find(
-        (st) => !completedSubtasks.includes(st.id) && (!st.dependencies || st.dependencies.every((d) => completedSubtasks.includes(d)))
-      );
-
-      const allComplete = completedSubtasks.length === context.state.slam.subtasks.length;
-
-      console.log(`[/execute-subtask] Completed: ${subtask.title}`);
-      console.log(`[/execute-subtask] Progress: ${completedSubtasks.length}/${context.state.slam.subtasks.length}`);
-
-      return {
-        success: true,
-        data: {
-          subtaskId,
-          title: subtask.title,
-          result: result.substring(0, 500),
-          completed: allComplete,
-          nextSubtaskId: nextSubtask?.id || null,
-        },
-        stateUpdates: {
-          slam: {
-            ...context.state.slam,
-            subtasks: updatedSubtasks,
-            currentSubtask: nextSubtask?.id || null,
-            completedSubtasks,
-          },
-        },
-        contextUpdates: {
-          currentSubtask: nextSubtask?.id || null,
-          lastCompletedSubtask: subtaskId,
-        },
-        nextSkill: allComplete ? "/quality-check" : undefined,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  },
-};
-
-skillRegistry.register(executeSubtaskSkill);
-
-export { ExecuteSubtaskParams };
-export type { ExecuteSubtaskData };