@shakudo/opencode-mattermost-control 0.3.45

package/src/thread-manager.ts

@@ -0,0 +1,231 @@
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { ThreadSessionMapping, ThreadRootPostContent } from "./models/index.js";
+import type { ThreadMappingStore } from "./persistence/thread-mapping-store.js";
+import type { OpenCodeSessionInfo } from "./opencode-session-registry.js";
+import { log } from "./logger.js";
+
+export class ThreadManager {
+  private mmClient: MattermostClient;
+  private store: ThreadMappingStore;
+
+  constructor(mmClient: MattermostClient, store: ThreadMappingStore) {
+    this.mmClient = mmClient;
+    this.store = store;
+  }
+
+  async createThread(
+    sessionInfo: OpenCodeSessionInfo,
+    mattermostUserId: string,
+    dmChannelId: string,
+    userPostId?: string,
+    channelId?: string,
+    ownerUsername?: string
+  ): Promise<ThreadSessionMapping> {
+    const existing = this.store.getBySessionId(sessionInfo.id);
+    if (existing) {
+      log.debug(`[ThreadManager] Thread already exists for session ${sessionInfo.shortId}`);
+      return existing;
+    }
+
+    const targetChannelId = channelId || dmChannelId;
+
+    const content: ThreadRootPostContent = {
+      projectName: sessionInfo.projectName,
+      directory: sessionInfo.directory,
+      sessionId: sessionInfo.id,
+      shortId: sessionInfo.shortId,
+      startedAt: new Date(),
+      sessionTitle: sessionInfo.title,
+      ownerUsername,
+    };
+
+    const message = this.formatThreadRootPost(content);
+
+    let threadRootPostId: string;
+
+    if (userPostId) {
+      threadRootPostId = userPostId;
+      log.info(`[ThreadManager] Creating reply: channel=${targetChannelId}, root_id=${userPostId}`);
+      try {
+        await this.mmClient.createPost(targetChannelId, message, userPostId);
+      } catch (e) {
+        log.warn(`[ThreadManager] First attempt failed (${e}), retrying...`);
+        await this.mmClient.createPost(targetChannelId, message, userPostId);
+      }
+    } else {
+      let rootPost;
+      try {
+        rootPost = await this.mmClient.createPost(targetChannelId, message);
+      } catch (e) {
+        log.warn(`[ThreadManager] First attempt failed, retrying...`);
+        rootPost = await this.mmClient.createPost(targetChannelId, message);
+      }
+      threadRootPostId = rootPost.id;
+    }
+
+    const mapping: ThreadSessionMapping = {
+      sessionId: sessionInfo.id,
+      threadRootPostId,
+      shortId: sessionInfo.shortId,
+      mattermostUserId,
+      dmChannelId,
+      channelId: targetChannelId,
+      projectName: sessionInfo.projectName,
+      directory: sessionInfo.directory,
+      sessionTitle: sessionInfo.title,
+      status: "active",
+      createdAt: new Date().toISOString(),
+      lastActivityAt: new Date().toISOString(),
+    };
+
+    try {
+      this.store.add(mapping);
+    } catch (e) {
+      log.error(`[ThreadManager] Failed to persist mapping, continuing in-memory:`, e);
+    }
+
+    log.info(`[ThreadManager] Created thread for session ${sessionInfo.shortId} (${sessionInfo.projectName}) in channel ${targetChannelId}`);
+    return mapping;
+  }
+
+  async endThread(sessionId: string): Promise<void> {
+    const mapping = this.store.getBySessionId(sessionId);
+    if (!mapping) {
+      log.debug(`[ThreadManager] No mapping found for session ${sessionId}`);
+      return;
+    }
+
+    if (mapping.status === "ended") {
+      return;
+    }
+
+    const now = new Date();
+    const duration = this.formatDuration(new Date(mapping.createdAt), now);
+    const message = this.formatSessionEndedPost(duration, now);
+
+    const targetChannelId = mapping.channelId || mapping.dmChannelId;
+    try {
+      await this.mmClient.createPost(targetChannelId, message, mapping.threadRootPostId);
+    } catch (e) {
+      log.error(`[ThreadManager] Failed to post session ended message:`, e);
+    }
+
+    mapping.status = "ended";
+    mapping.endedAt = now.toISOString();
+    mapping.lastActivityAt = now.toISOString();
+    this.store.update(mapping);
+
+    log.info(`[ThreadManager] Ended thread for session ${mapping.shortId}`);
+  }
+
+  async reconnectThread(sessionId: string): Promise<ThreadSessionMapping | null> {
+    const mapping = this.store.getBySessionId(sessionId);
+    if (!mapping) {
+      return null;
+    }
+
+    if (mapping.status === "disconnected") {
+      mapping.status = "active";
+      mapping.lastActivityAt = new Date().toISOString();
+      this.store.update(mapping);
+
+      const targetChannelId = mapping.channelId || mapping.dmChannelId;
+      try {
+        await this.mmClient.createPost(
+          targetChannelId,
+          ":arrows_counterclockwise: **Session reconnected**",
+          mapping.threadRootPostId
+        );
+      } catch (e) {
+        log.warn(`[ThreadManager] Failed to post reconnect message:`, e);
+      }
+
+      log.info(`[ThreadManager] Reconnected thread for session ${mapping.shortId}`);
+    }
+
+    return mapping;
+  }
+
+  markDisconnected(sessionId: string): void {
+    const mapping = this.store.getBySessionId(sessionId);
+    if (!mapping || mapping.status !== "active") {
+      return;
+    }
+
+    mapping.status = "disconnected";
+    mapping.lastActivityAt = new Date().toISOString();
+    this.store.update(mapping);
+
+    log.info(`[ThreadManager] Marked session ${mapping.shortId} as disconnected`);
+  }
+
+  getMapping(sessionId: string): ThreadSessionMapping | null {
+    return this.store.getBySessionId(sessionId);
+  }
+
+  getMappingByThreadId(threadRootPostId: string): ThreadSessionMapping | null {
+    return this.store.getByThreadRootPostId(threadRootPostId);
+  }
+
+  updateActivity(sessionId: string): void {
+    const mapping = this.store.getBySessionId(sessionId);
+    if (mapping) {
+      mapping.lastActivityAt = new Date().toISOString();
+      this.store.update(mapping);
+    }
+  }
+
+  private formatThreadRootPost(content: ThreadRootPostContent): string {
+    const jobId = process.env.MY_JOB_ID || "";
+    const jobIdShort = jobId.substring(0, 5);
+
+    const lines = [
+      `:rocket: **OpenCode Session Started**`,
+      ``,
+      `**Project**: ${content.projectName}`,
+      `**Directory**: ${content.directory}`,
+      `**Session**: ${content.shortId}`,
+      `**My session ID**: ${jobIdShort}`,
+      `**Started**: ${content.startedAt.toISOString()}`,
+    ];
+
+    if (content.sessionTitle) {
+      lines.splice(2, 0, `**Title**: ${content.sessionTitle}`);
+    }
+
+    if (content.ownerUsername) {
+      lines.splice(2, 0, `**Owner**: @${content.ownerUsername}`);
+    }
+
+    lines.push(``, `_Reply in this thread to send prompts to this session._`);
+
+    return lines.join("\n");
+  }
+
+  private formatSessionEndedPost(duration: string, endedAt: Date): string {
+    return [
+      `:checkered_flag: **Session Ended**`,
+      ``,
+      `**Duration**: ${duration}`,
+      `**Ended**: ${endedAt.toISOString()}`,
+      ``,
+      `_This thread is now read-only. Start a new session for a new thread._`,
+    ].join("\n");
+  }
+
+  private formatDuration(start: Date, end: Date): string {
+    const ms = end.getTime() - start.getTime();
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60) {
+      return `${minutes} minute${minutes !== 1 ? "s" : ""}`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (hours < 24) {
+      return `${hours} hour${hours !== 1 ? "s" : ""} ${remainingMinutes} minute${remainingMinutes !== 1 ? "s" : ""}`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return `${days} day${days !== 1 ? "s" : ""} ${remainingHours} hour${remainingHours !== 1 ? "s" : ""}`;
+  }
+}

package/src/todo-manager.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+import { log } from "./logger";
+
+export const TodoItemSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  status: z.string(),
+  priority: z.string(),
+});
+
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+
+export interface TodoPostInfo {
+  postId: string;
+  lastUpdated: number;
+  todos: TodoItem[];
+}
+
+const STATUS_ICONS: Record<string, string> = {
+  completed: "✅",
+  in_progress: "🔄",
+  pending: "⏳",
+  cancelled: "❌",
+};
+
+const PRIORITY_MARKERS: Record<string, string> = {
+  high: "🔴",
+  medium: "🟡",
+  low: "🟢",
+};
+
+export class TodoManager {
+  private todoPostsBySession: Map<string, TodoPostInfo> = new Map();
+  private mmClient: any;
+  private threadRootsBySession: Map<string, string> = new Map();
+  private channelIdsBySession: Map<string, string> = new Map();
+
+  constructor(mmClient: any) {
+    this.mmClient = mmClient;
+  }
+
+  setThreadRoot(sessionId: string, threadRootPostId: string, channelId?: string) {
+    this.threadRootsBySession.set(sessionId, threadRootPostId);
+    if (channelId) {
+      this.channelIdsBySession.set(sessionId, channelId);
+    }
+  }
+  
+  getChannelId(sessionId: string): string | undefined {
+    return this.channelIdsBySession.get(sessionId);
+  }
+
+  formatTodoList(todos: TodoItem[]): string {
+    if (!todos || todos.length === 0) {
+      return "";
+    }
+
+    const completed = todos.filter((t) => t.status === "completed").length;
+    const total = todos.length;
+
+    let output = `📋 **Task List** (${completed}/${total} complete)\n\n`;
+
+    const sortedTodos = [...todos].sort((a, b) => {
+      const statusOrder: Record<string, number> = {
+        in_progress: 0,
+        pending: 1,
+        completed: 2,
+        cancelled: 3,
+      };
+      const priorityOrder: Record<string, number> = {
+        high: 0,
+        medium: 1,
+        low: 2,
+      };
+
+      const statusDiff =
+        (statusOrder[a.status] ?? 99) - (statusOrder[b.status] ?? 99);
+      if (statusDiff !== 0) return statusDiff;
+
+      return (
+        (priorityOrder[a.priority] ?? 99) - (priorityOrder[b.priority] ?? 99)
+      );
+    });
+
+    for (const todo of sortedTodos) {
+      const statusIcon = STATUS_ICONS[todo.status] || "❓";
+      const priorityMarker =
+        todo.priority === "high" ? ` ${PRIORITY_MARKERS.high}` : "";
+
+      if (todo.status === "completed") {
+        output += `${statusIcon} ~~${todo.content}~~${priorityMarker}\n`;
+      } else if (todo.status === "cancelled") {
+        output += `${statusIcon} ~~${todo.content}~~ _(cancelled)_\n`;
+      } else {
+        output += `${statusIcon} ${todo.content}${priorityMarker}\n`;
+      }
+    }
+
+    return output.trim();
+  }
+
+  async updateTodoPost(
+    sessionId: string,
+    todos: TodoItem[],
+    channelId: string
+  ): Promise<void> {
+    const threadRootPostId = this.threadRootsBySession.get(sessionId);
+    if (!threadRootPostId) {
+      log.debug(
+        `[TodoManager] No thread root for session ${sessionId.substring(0, 8)}`
+      );
+      return;
+    }
+
+    const formattedContent = this.formatTodoList(todos);
+    
+    if (!formattedContent) {
+      log.debug(`[TodoManager] Empty todo list, skipping update`);
+      return;
+    }
+    
+    const existingPost = this.todoPostsBySession.get(sessionId);
+
+    try {
+      if (existingPost) {
+        try {
+          await this.mmClient.deletePost(existingPost.postId);
+        } catch (e) {
+          log.debug(`[TodoManager] Failed to delete old todo post (may already be deleted)`);
+        }
+      }
+      
+      const newPost = await this.mmClient.createPost(
+        channelId,
+        formattedContent,
+        threadRootPostId
+      );
+      
+      this.todoPostsBySession.set(sessionId, {
+        postId: newPost.id,
+        lastUpdated: Date.now(),
+        todos,
+      });
+      
+      log.debug(
+        `[TodoManager] Created todo post at end of thread for session ${sessionId.substring(0, 8)}`
+      );
+    } catch (e) {
+      log.error(`[TodoManager] Failed to update todo post:`, e);
+    }
+  }
+
+  getTodoPost(sessionId: string): TodoPostInfo | undefined {
+    return this.todoPostsBySession.get(sessionId);
+  }
+
+  clearSession(sessionId: string) {
+    this.todoPostsBySession.delete(sessionId);
+    this.threadRootsBySession.delete(sessionId);
+    this.channelIdsBySession.delete(sessionId);
+  }
+}