heartbeat-opencode-plugin 0.1.0

package/task-manager/index.ts

@@ -0,0 +1,459 @@
+import * as fs from "fs";
+import * as path from "path";
+import { type Plugin, tool } from "@opencode-ai/plugin";
+import { getTasksFilePath, loadConfig } from "../config";
+import { appendLog } from "../memory";
+
+export type TaskStatus = "pending" | "running" | "done" | "blocked" | "raised";
+export type TaskPriority = "low" | "normal" | "high" | "critical";
+
+export interface Task {
+  program: string;
+  taskId: string;
+  parentTaskId?: string;
+  status: TaskStatus;
+  description: string;
+  priority: TaskPriority;
+  references?: string;
+  createdAt: string;
+  updatedAt: string;
+  resolvedAt?: string;
+}
+
+interface TaskFilters {
+  program?: string;
+  parentTaskId?: string;
+  status?: TaskStatus;
+  priority?: TaskPriority;
+}
+
+const VALID_STATUSES = new Set<TaskStatus>([
+  "pending",
+  "running",
+  "done",
+  "blocked",
+  "raised",
+]);
+const VALID_PRIORITIES = new Set<TaskPriority>([
+  "low",
+  "normal",
+  "high",
+  "critical",
+]);
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function normalizeStatus(input?: string): TaskStatus | undefined {
+  if (!input) return undefined;
+  const value = input.toLowerCase() as TaskStatus;
+  return VALID_STATUSES.has(value) ? value : undefined;
+}
+
+function normalizePriority(input?: string): TaskPriority | undefined {
+  if (!input) return undefined;
+  const value = input.toLowerCase() as TaskPriority;
+  return VALID_PRIORITIES.has(value) ? value : undefined;
+}
+
+class TaskStore {
+  private readonly filePath: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+    this.ensureFileExists();
+  }
+
+  private ensureFileExists(): void {
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    if (!fs.existsSync(this.filePath)) {
+      fs.writeFileSync(this.filePath, JSON.stringify([], null, 2));
+    }
+  }
+
+  read(): Task[] {
+    try {
+      const data = fs.readFileSync(this.filePath, "utf-8");
+      return JSON.parse(data) as Task[];
+    } catch (error) {
+      console.error("Failed to read tasks:", error);
+      return [];
+    }
+  }
+
+  write(tasks: Task[]): void {
+    fs.writeFileSync(this.filePath, JSON.stringify(tasks, null, 2));
+  }
+
+  getFilePath(): string {
+    return this.filePath;
+  }
+}
+
+let store: TaskStore | null = null;
+
+function ensureStore(projectDir?: string, filePath?: string): TaskStore {
+  loadConfig(projectDir);
+  const resolvedPath = filePath ?? getTasksFilePath();
+
+  if (store && store.getFilePath() === resolvedPath) {
+    return store;
+  }
+
+  store = new TaskStore(resolvedPath);
+  return store;
+}
+
+function storeInstance(): TaskStore {
+  if (!store) {
+    return ensureStore();
+  }
+  return store;
+}
+
+function taskKey(program: string, taskId: string): string {
+  return `${program}::${taskId}`;
+}
+
+export function initStore(projectDir?: string, filePath?: string): void {
+  ensureStore(projectDir, filePath);
+}
+
+export function listTasks(filters?: TaskFilters): Task[] {
+  const tasks = storeInstance().read();
+  return tasks.filter((task) => {
+    if (filters?.program && task.program !== filters.program) return false;
+    if (filters?.parentTaskId && task.parentTaskId !== filters.parentTaskId) return false;
+    if (filters?.status && task.status !== filters.status) return false;
+    if (filters?.priority && task.priority !== filters.priority) return false;
+    return true;
+  });
+}
+
+export function getTask(program: string, taskId: string): Task | undefined {
+  const tasks = storeInstance().read();
+  return tasks.find((task) => taskKey(task.program, task.taskId) === taskKey(program, taskId));
+}
+
+export function createTask(input: {
+  program: string;
+  taskId: string;
+  parentTaskId?: string;
+  description: string;
+  status?: TaskStatus;
+  priority?: TaskPriority;
+  references?: string;
+}): Task {
+  const instance = storeInstance();
+  const tasks = instance.read();
+
+  const duplicate = tasks.find((task) => taskKey(task.program, task.taskId) === taskKey(input.program, input.taskId));
+  if (duplicate) {
+    throw new Error(`Task already exists: [${input.program}][${input.taskId}]`);
+  }
+
+  const timestamp = nowIso();
+  const task: Task = {
+    program: input.program,
+    taskId: input.taskId,
+    parentTaskId: input.parentTaskId,
+    description: input.description,
+    status: input.status ?? "pending",
+    priority: input.priority ?? "normal",
+    references: input.references,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+  };
+
+  tasks.push(task);
+  instance.write(tasks);
+  appendLog(`[${task.program}][${task.taskId}] Task created with status=${task.status}`);
+  return task;
+}
+
+export function updateTask(input: {
+  program: string;
+  taskId: string;
+  parentTaskId?: string;
+  description?: string;
+  status?: TaskStatus;
+  priority?: TaskPriority;
+  references?: string;
+}): Task | null {
+  const instance = storeInstance();
+  const tasks = instance.read();
+  const index = tasks.findIndex((task) => taskKey(task.program, task.taskId) === taskKey(input.program, input.taskId));
+
+  if (index === -1) return null;
+
+  const existing = tasks[index];
+  const updated: Task = {
+    ...existing,
+    ...("parentTaskId" in input ? { parentTaskId: input.parentTaskId } : {}),
+    ...("description" in input ? { description: input.description ?? existing.description } : {}),
+    ...("status" in input ? { status: input.status ?? existing.status } : {}),
+    ...("priority" in input ? { priority: input.priority ?? existing.priority } : {}),
+    ...("references" in input ? { references: input.references } : {}),
+    updatedAt: nowIso(),
+  };
+
+  if (updated.status === "done" && !updated.resolvedAt) {
+    updated.resolvedAt = updated.updatedAt;
+  }
+  if (updated.status !== "done") {
+    delete updated.resolvedAt;
+  }
+
+  tasks[index] = updated;
+  instance.write(tasks);
+  appendLog(`[${updated.program}][${updated.taskId}] Task updated status=${updated.status}`);
+  return updated;
+}
+
+export function markTaskDone(program: string, taskId: string): Task | null {
+  return updateTask({
+    program,
+    taskId,
+    status: "done",
+  });
+}
+
+export function deleteTask(program: string, taskId: string): boolean {
+  const instance = storeInstance();
+  const tasks = instance.read();
+  const filtered = tasks.filter((task) => taskKey(task.program, task.taskId) !== taskKey(program, taskId));
+
+  if (filtered.length === tasks.length) {
+    return false;
+  }
+
+  instance.write(filtered);
+  appendLog(`[${program}][${taskId}] Task deleted`);
+  return true;
+}
+
+export function getTaskStorePath(): string {
+  return storeInstance().getFilePath();
+}
+
+export const TaskManagerPlugin: Plugin = async (ctx) => {
+  initStore(ctx.directory);
+
+  return {
+    tool: {
+      task_create: tool({
+        description:
+          "Create a task tracked by [program][taskId]. Use this before running a cron cycle.",
+        args: {
+          program: tool.schema.string().describe("Program name used for task and memory tags"),
+          taskId: tool.schema.string().describe("Task identifier in kebab-case"),
+          parentTaskId: tool.schema
+            .string()
+            .optional()
+            .describe("Optional parent task ID to create task hierarchies"),
+          description: tool.schema.string().describe("Human description of the task"),
+          status: tool.schema
+            .string()
+            .optional()
+            .describe("Optional status: pending, running, blocked, raised, done"),
+          priority: tool.schema
+            .string()
+            .optional()
+            .describe("Optional priority: low, normal, high, critical"),
+          references: tool.schema
+            .string()
+            .optional()
+            .describe("Optional file paths or notes for this task"),
+        },
+        async execute(args) {
+          const status = normalizeStatus(args.status);
+          if (args.status && !status) {
+            return `Invalid status: ${args.status}. Use pending|running|blocked|raised|done`;
+          }
+
+          const priority = normalizePriority(args.priority);
+          if (args.priority && !priority) {
+            return `Invalid priority: ${args.priority}. Use low|normal|high|critical`;
+          }
+
+          try {
+            const task = createTask({
+              program: args.program,
+              taskId: args.taskId,
+              parentTaskId: args.parentTaskId,
+              description: args.description,
+              status,
+              priority,
+              references: args.references,
+            });
+            return `Created task [${task.program}][${task.taskId}] status=${task.status} priority=${task.priority}`;
+          } catch (error) {
+            return `Failed to create task: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        },
+      }),
+
+      task_list: tool({
+        description: "List tasks, optionally filtered by program/status/priority.",
+        args: {
+          program: tool.schema.string().optional().describe("Optional program filter"),
+          parentTaskId: tool.schema.string().optional().describe("Optional parent task filter"),
+          status: tool.schema.string().optional().describe("Optional status filter"),
+          priority: tool.schema.string().optional().describe("Optional priority filter"),
+        },
+        async execute(args) {
+          const status = normalizeStatus(args.status);
+          if (args.status && !status) {
+            return `Invalid status: ${args.status}. Use pending|running|blocked|raised|done`;
+          }
+
+          const priority = normalizePriority(args.priority);
+          if (args.priority && !priority) {
+            return `Invalid priority: ${args.priority}. Use low|normal|high|critical`;
+          }
+
+          const tasks = listTasks({
+            program: args.program,
+            parentTaskId: args.parentTaskId,
+            status,
+            priority,
+          });
+          if (tasks.length === 0) {
+            return "No matching tasks found.";
+          }
+          return JSON.stringify(tasks, null, 2);
+        },
+      }),
+
+      task_get: tool({
+        description: "Get a single task by [program][taskId].",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task ID"),
+        },
+        async execute(args) {
+          const task = getTask(args.program, args.taskId);
+          if (!task) {
+            return `Task not found: [${args.program}][${args.taskId}]`;
+          }
+          return JSON.stringify(task, null, 2);
+        },
+      }),
+
+      task_update: tool({
+        description: "Update task metadata or status.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task ID"),
+          parentTaskId: tool.schema
+            .string()
+            .optional()
+            .describe("Updated parent task ID"),
+          description: tool.schema.string().optional().describe("Updated description"),
+          status: tool.schema.string().optional().describe("Updated status"),
+          priority: tool.schema.string().optional().describe("Updated priority"),
+          references: tool.schema.string().optional().describe("Updated references"),
+        },
+        async execute(args) {
+          const status = normalizeStatus(args.status);
+          if (args.status && !status) {
+            return `Invalid status: ${args.status}. Use pending|running|blocked|raised|done`;
+          }
+
+          const priority = normalizePriority(args.priority);
+          if (args.priority && !priority) {
+            return `Invalid priority: ${args.priority}. Use low|normal|high|critical`;
+          }
+
+          const updates: {
+            program: string;
+            taskId: string;
+            parentTaskId?: string;
+            description?: string;
+            status?: TaskStatus;
+            priority?: TaskPriority;
+            references?: string;
+          } = {
+            program: args.program,
+            taskId: args.taskId,
+          };
+
+          if (args.parentTaskId !== undefined) {
+            updates.parentTaskId = args.parentTaskId;
+          }
+          if (args.description !== undefined) {
+            updates.description = args.description;
+          }
+          if (args.status !== undefined) {
+            updates.status = status;
+          }
+          if (args.priority !== undefined) {
+            updates.priority = priority;
+          }
+          if (args.references !== undefined) {
+            updates.references = args.references;
+          }
+
+          const task = updateTask(updates);
+
+          if (!task) {
+            return `Task not found: [${args.program}][${args.taskId}]`;
+          }
+
+          return `Updated [${task.program}][${task.taskId}] status=${task.status} priority=${task.priority}`;
+        },
+      }),
+
+      task_mark_done: tool({
+        description: "Mark a task as done after it is resolved.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task ID"),
+        },
+        async execute(args) {
+          const task = markTaskDone(args.program, args.taskId);
+          if (!task) {
+            return `Task not found: [${args.program}][${args.taskId}]`;
+          }
+          return `Marked done [${task.program}][${task.taskId}]`;
+        },
+      }),
+
+      task_delete: tool({
+        description: "Delete a task from the task manager.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task ID"),
+        },
+        async execute(args) {
+          const deleted = deleteTask(args.program, args.taskId);
+          if (!deleted) {
+            return `Task not found: [${args.program}][${args.taskId}]`;
+          }
+          return `Deleted [${args.program}][${args.taskId}]`;
+        },
+      }),
+
+      task_store_info: tool({
+        description: "Get task store file path and current task count.",
+        args: {},
+        async execute() {
+          const tasks = listTasks();
+          return JSON.stringify(
+            {
+              path: getTaskStorePath(),
+              count: tasks.length,
+            },
+            null,
+            2,
+          );
+        },
+      }),
+    },
+  };
+};