heartbeat-opencode-plugin 0.1.0

package/memory/index.ts

@@ -0,0 +1,307 @@
+import * as fs from "fs";
+import { type Plugin, tool } from "@opencode-ai/plugin";
+import { getLogFilePath, getLogsDir, loadConfig } from "../config";
+
+function ensureDir(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function isoNow(): string {
+  return new Date().toISOString();
+}
+
+export function initLogger(projectDir?: string): void {
+  loadConfig(projectDir);
+  ensureDir(getLogsDir());
+}
+
+export function appendLog(line: string): void {
+  ensureDir(getLogsDir());
+  const entry = `[${isoNow()}] ${line}\n`;
+  fs.appendFileSync(getLogFilePath(), entry);
+}
+
+export function writeLog(input: {
+  program: string;
+  taskId: string;
+  message: string;
+}): string {
+  const tagged = `[${input.program}][${input.taskId}] ${input.message}`;
+  appendLog(tagged);
+  return `Logged: ${tagged}`;
+}
+
+const LOG_ENTRY_PREFIX =
+  /^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\]\s/;
+
+function readAllEntries(limit?: number): string[] {
+  const path = getLogFilePath();
+  if (!fs.existsSync(path)) return [];
+
+  const raw = fs.readFileSync(path, "utf-8");
+  if (raw.trim().length === 0) return [];
+
+  const lines = raw.split(/\r?\n/);
+  const entries: string[] = [];
+  let current: string[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+
+    // Ignore terminal newline from file ending; preserve intentional blank lines inside entries.
+    if (index === lines.length - 1 && line.length === 0) {
+      continue;
+    }
+
+    if (line.length === 0 && current.length === 0) {
+      continue;
+    }
+
+    if (LOG_ENTRY_PREFIX.test(line)) {
+      if (current.length > 0) {
+        entries.push(current.join("\n"));
+      }
+      current = [line];
+      continue;
+    }
+
+    // Continuation of a multiline log entry.
+    if (current.length > 0) {
+      current.push(line);
+      continue;
+    }
+
+    // Backward compatibility for malformed/legacy lines without timestamp.
+    current = [line];
+  }
+
+  if (current.length > 0) {
+    entries.push(current.join("\n"));
+  }
+
+  if (limit && limit > 0) {
+    return entries.slice(-limit);
+  }
+  return entries;
+}
+
+export function readAllLogs(limit?: number): string[] {
+  return readAllEntries(limit);
+}
+
+export function searchMemory(input: {
+  program: string;
+  taskId?: string;
+  limit?: number;
+}): string[] {
+  const programTag = `[${input.program}]`;
+  const taskTag = input.taskId ? `[${input.program}][${input.taskId}]` : null;
+  const entries = readAllEntries();
+
+  const matches = entries.filter((entry) => {
+    if (taskTag) return entry.includes(taskTag);
+    return entry.includes(programTag);
+  });
+
+  if (input.limit && input.limit > 0) {
+    return matches.slice(-input.limit);
+  }
+  return matches;
+}
+
+export function readProgram(input: {
+  program: string;
+  limit?: number;
+}): string[] {
+  return searchMemory(input);
+}
+
+export function readProgramTask(input: {
+  program: string;
+  taskId: string;
+  limit?: number;
+}): string[] {
+  return searchMemory(input);
+}
+
+export function grepLogs(input: { pattern: string; limit?: number }): string[] {
+  const regex = new RegExp(input.pattern);
+  const entries = readAllEntries();
+  const matches = entries.filter((entry) => regex.test(entry));
+
+  if (input.limit && input.limit > 0) {
+    return matches.slice(-input.limit);
+  }
+  return matches;
+}
+
+export function tailLogs(lines = 50): string[] {
+  return readAllLogs(lines);
+}
+
+export function getLogInfo(): {
+  path: string;
+  exists: boolean;
+  sizeBytes: number;
+  lineCount: number;
+} {
+  const path = getLogFilePath();
+  const exists = fs.existsSync(path);
+
+  if (!exists) {
+    return {
+      path,
+      exists: false,
+      sizeBytes: 0,
+      lineCount: 0,
+    };
+  }
+
+  const stats = fs.statSync(path);
+  const lineCount = readAllLogs().length;
+  return {
+    path,
+    exists: true,
+    sizeBytes: stats.size,
+    lineCount,
+  };
+}
+
+function linesToText(lines: string[]): string {
+  if (lines.length === 0) return "No matching log entries found.";
+  return lines.join("\n\n");
+}
+
+export const MemoryPlugin: Plugin = async (ctx) => {
+  initLogger(ctx.directory);
+
+  return {
+    tool: {
+      memory_write: tool({
+        description: "Write a tagged log line as [program][taskId] message.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task identifier"),
+          message: tool.schema.string().describe("Message content"),
+        },
+        async execute(args) {
+          return writeLog(args);
+        },
+      }),
+
+      write_log: tool({
+        description:
+          "Alias for memory_write. Writes tagged memory lines into the shared heartbeat log.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task identifier"),
+          message: tool.schema.string().describe("Message content"),
+        },
+        async execute(args) {
+          return writeLog(args);
+        },
+      }),
+
+      search_memory: tool({
+        description:
+          "Search memory by [program] and optional [taskId]. Use this on boot to restore previous cycle context.",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema
+            .string()
+            .optional()
+            .describe(
+              "Optional task identifier for exact [program][taskId] lookup",
+            ),
+          limit: tool.schema
+            .number()
+            .optional()
+            .describe("Return only the most recent N matching lines"),
+        },
+        async execute(args) {
+          const lines = searchMemory(args);
+          return linesToText(lines);
+        },
+      }),
+
+      read_program: tool({
+        description: "Read all log lines containing [program].",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          limit: tool.schema.number().optional().describe("Optional max lines"),
+        },
+        async execute(args) {
+          return linesToText(readProgram(args));
+        },
+      }),
+
+      read_program_task: tool({
+        description: "Read all log lines containing [program][taskId].",
+        args: {
+          program: tool.schema.string().describe("Program name"),
+          taskId: tool.schema.string().describe("Task identifier"),
+          limit: tool.schema.number().optional().describe("Optional max lines"),
+        },
+        async execute(args) {
+          return linesToText(readProgramTask(args));
+        },
+      }),
+
+      memory_grep: tool({
+        description:
+          "Regex grep across the shared heartbeat log file. Useful for free-form memory queries.",
+        args: {
+          pattern: tool.schema.string().describe("JavaScript regex pattern"),
+          limit: tool.schema.number().optional().describe("Optional max lines"),
+        },
+        async execute(args) {
+          try {
+            return linesToText(grepLogs(args));
+          } catch {
+            return `Invalid regex pattern: ${args.pattern}`;
+          }
+        },
+      }),
+
+      grep_logs: tool({
+        description: "Alias for memory_grep.",
+        args: {
+          pattern: tool.schema.string().describe("JavaScript regex pattern"),
+          limit: tool.schema.number().optional().describe("Optional max lines"),
+        },
+        async execute(args) {
+          try {
+            return linesToText(grepLogs(args));
+          } catch {
+            return `Invalid regex pattern: ${args.pattern}`;
+          }
+        },
+      }),
+
+      tail_logs: tool({
+        description: "Return recent lines from the shared heartbeat log.",
+        args: {
+          lines: tool.schema
+            .number()
+            .optional()
+            .describe("Number of lines to return"),
+        },
+        async execute(args) {
+          return linesToText(tailLogs(args.lines ?? 50));
+        },
+      }),
+
+      log_info: tool({
+        description: "Get shared log file path and stats.",
+        args: {},
+        async execute() {
+          return JSON.stringify(getLogInfo(), null, 2);
+        },
+      }),
+    },
+  };
+};
+
+export { getLogFilePath };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "heartbeat-opencode-plugin",
+  "version": "0.1.0",
+  "description": "Heartbeat Runtime",
+  "type": "module",
+  "main": "./index.ts",
+  "module": "./index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "config",
+    "memory",
+    "scheduler",
+    "task-manager",
+    "heartbeat.config.json",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "plugin",
+    "scheduler",
+    "memory",
+    "cron"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "bunx tsc",
+    "prepublishOnly": "bun run typecheck"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.9"
+  }
+}