tmux-ide 1.2.1 → 2.0.0

package/src/lib/event-log.test.ts

@@ -0,0 +1,189 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { appendEvent, readEvents, type OrchestratorEvent } from "./event-log.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-evlog-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("appendEvent", () => {
+  it("creates .tasks/ and events.log if they don't exist", () => {
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      taskId: "001",
+      agent: "Agent 1",
+      message: "Dispatched task 001 to Agent 1",
+    });
+
+    expect(existsSync(join(tmpDir, ".tasks", "events.log"))).toBeTruthy();
+  });
+
+  it("appends events as JSON lines", () => {
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      taskId: "001",
+      message: "first",
+    });
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:01:00Z",
+      type: "completion",
+      taskId: "001",
+      message: "second",
+    });
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(2);
+    expect(events[0]!.type).toBe("dispatch");
+    expect(events[1]!.type).toBe("completion");
+  });
+
+  it("works without optional fields", () => {
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "error",
+      message: "something broke",
+    });
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(1);
+    expect(events[0]!.taskId).toBe(undefined);
+    expect(events[0]!.agent).toBe(undefined);
+  });
+});
+
+describe("readEvents", () => {
+  it("returns empty array when log doesn't exist", () => {
+    expect(readEvents(tmpDir)).toEqual([]);
+  });
+
+  it("returns all event types", () => {
+    const types: Array<OrchestratorEvent["type"]> = [
+      "dispatch",
+      "stall",
+      "completion",
+      "retry",
+      "reconcile",
+      "error",
+    ];
+    for (const type of types) {
+      appendEvent(tmpDir, { timestamp: "2026-01-01T00:00:00Z", type, message: type });
+    }
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(6);
+    expect(events.map((e) => e.type)).toEqual(types);
+  });
+
+  it("skips corrupted lines and returns valid events", () => {
+    const tasksDir = join(tmpDir, ".tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    const logPath = join(tasksDir, "events.log");
+    const validEvent = JSON.stringify({
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      message: "valid event",
+    });
+    // Write: valid line, corrupted line, another valid line
+    writeFileSync(logPath, `${validEvent}\nnot json at all\n${validEvent}\n`);
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(2);
+    expect(events[0]!.message).toBe("valid event");
+    expect(events[1]!.message).toBe("valid event");
+  });
+
+  it("reads events from both current and rotated log files", () => {
+    const tasksDir = join(tmpDir, ".tasks");
+    mkdirSync(tasksDir, { recursive: true });
+
+    const oldEvent = JSON.stringify({
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      message: "old event",
+    });
+    const newEvent = JSON.stringify({
+      timestamp: "2026-01-02T00:00:00Z",
+      type: "completion",
+      message: "new event",
+    });
+
+    writeFileSync(join(tasksDir, "events.log.1"), oldEvent + "\n");
+    writeFileSync(join(tasksDir, "events.log"), newEvent + "\n");
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(2);
+    expect(events[0]!.message).toBe("old event");
+    expect(events[1]!.message).toBe("new event");
+  });
+});
+
+describe("log rotation", () => {
+  it("rotates events.log when it exceeds 1MB", () => {
+    const tasksDir = join(tmpDir, ".tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    const logPath = join(tasksDir, "events.log");
+
+    // Write a file just over 1MB directly
+    const event = JSON.stringify({
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      taskId: "001",
+      message: "x".repeat(200),
+    });
+    const lineSize = Buffer.byteLength(event + "\n");
+    const linesNeeded = Math.ceil(1048577 / lineSize);
+    writeFileSync(logPath, (event + "\n").repeat(linesNeeded));
+
+    expect(statSync(logPath).size > 1048576).toBeTruthy();
+
+    // Next appendEvent should trigger rotation
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-02T00:00:00Z",
+      type: "completion",
+      taskId: "002",
+      message: "trigger rotation",
+    });
+
+    // events.log should now be small (just the new event)
+    expect(statSync(logPath).size < 1024).toBeTruthy();
+
+    // Rotated file should exist with the old content
+    const rotatedPath = join(tasksDir, "events.log.1");
+    expect(existsSync(rotatedPath)).toBeTruthy();
+    expect(statSync(rotatedPath).size > 1048576).toBeTruthy();
+
+    // readEvents should return events from both files
+    const events = readEvents(tmpDir);
+    expect(events.length > linesNeeded).toBeTruthy();
+    expect(events[events.length - 1]!.message).toBe("trigger rotation");
+  });
+
+  it("does not rotate when file is under 1MB", () => {
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "dispatch",
+      message: "small event",
+    });
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:01:00Z",
+      type: "completion",
+      message: "another small event",
+    });
+
+    const rotatedPath = join(tmpDir, ".tasks", "events.log.1");
+    expect(!existsSync(rotatedPath)).toBeTruthy();
+
+    const events = readEvents(tmpDir);
+    expect(events.length).toBe(2);
+  });
+});

package/src/lib/event-log.ts

@@ -0,0 +1,237 @@
+import {
+  appendFileSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { StructuredEventSchemaZ } from "../schemas/domain.ts";
+import type { z } from "zod";
+import { fireWebhooks, type WebhookConfig } from "./webhook.ts";
+
+export type EventType =
+  | "dispatch"
+  | "stall"
+  | "completion"
+  | "retry"
+  | "reconcile"
+  | "error"
+  | "task_created"
+  | "status_change"
+  | "send"
+  | "notify"
+  | "milestone_validating"
+  | "milestone_complete"
+  | "validation_dispatch"
+  | "remediation"
+  | "validation_failed"
+  | "planning"
+  | "mission_complete"
+  | "discovered_issue"
+  | "research_dispatch"
+  | "research_finding"
+  | "agent_heartbeat"
+  | "session_start"
+  | "session_end";
+
+export interface OrchestratorEvent {
+  timestamp: string;
+  type: EventType;
+  taskId?: string;
+  agent?: string;
+  message: string;
+}
+
+export type StructuredEvent = z.infer<typeof StructuredEventSchemaZ>;
+
+let _webhooks: WebhookConfig[] = [];
+
+/** Configure webhook URLs for event delivery. Call once at startup. */
+export function setWebhookConfig(webhooks: WebhookConfig[]): void {
+  _webhooks = webhooks;
+}
+
+/**
+ * Generate a human-readable message from a structured event's typed fields.
+ */
+export function formatEventMessage(event: StructuredEvent): string {
+  switch (event.type) {
+    case "dispatch":
+      return `Dispatched task ${event.taskId} to ${event.agent}`;
+    case "completion": {
+      const duration =
+        event.durationMs != null ? ` in ${Math.round(event.durationMs / 1000)}s` : "";
+      return `Task ${event.taskId} completed by ${event.agent}${duration}`;
+    }
+    case "stall":
+      return `Stall detected: task ${event.taskId} by ${event.agent} (${Math.floor(event.elapsedMs / 60000)}m)`;
+    case "retry":
+      return `Retry ${event.attempt}/${event.maxRetries} for task ${event.taskId}: ${event.reason}`;
+    case "reconcile":
+      return `Reconcile task ${event.taskId}: agent "${event.previousAgent}" ${event.action}`;
+    case "error": {
+      const ctx = [event.taskId && `task ${event.taskId}`, event.agent && `agent ${event.agent}`]
+        .filter(Boolean)
+        .join(", ");
+      const code = event.code ? ` [${event.code}]` : "";
+      return ctx ? `Error (${ctx}): ${event.message}${code}` : `Error: ${event.message}${code}`;
+    }
+    case "task_created":
+      return `Task ${event.taskId} created: "${event.title}"`;
+    case "status_change":
+      return `Task ${event.taskId} status: ${event.from} → ${event.to}`;
+    case "send": {
+      const preview =
+        event.message.length > 50 ? event.message.slice(0, 50) + "..." : event.message;
+      return `Sent to ${event.target}: "${preview}"`;
+    }
+    case "notify": {
+      const preview =
+        event.message.length > 50 ? event.message.slice(0, 50) + "..." : event.message;
+      return `Notified ${event.target}: "${preview}"`;
+    }
+    case "milestone_validating":
+      return event.title && event.milestoneId
+        ? `Milestone "${event.title}" (${event.milestoneId}) entered validation`
+        : "Milestone entered validation";
+    case "milestone_complete":
+      return event.title && event.milestoneId
+        ? `Milestone "${event.title}" (${event.milestoneId}) completed`
+        : "Milestone completed";
+    case "validation_dispatch":
+      return event.title && event.target
+        ? `Dispatched validation for "${event.title}" to ${event.target}`
+        : "Dispatched milestone validation";
+    case "remediation":
+      return event.assertionId
+        ? `Created remediation task ${event.taskId} for assertion ${event.assertionId}`
+        : `Created remediation task ${event.taskId}`;
+    case "validation_failed":
+      return event.title && event.failedCount != null
+        ? `Milestone "${event.title}" validation failed (${event.failedCount} assertion(s))`
+        : "Milestone validation failed";
+    case "planning":
+      return event.target
+        ? `Dispatched mission planning to ${event.target}`
+        : "Dispatched mission planning";
+    case "mission_complete":
+      return event.title ? `Mission "${event.title}" completed` : "Mission completed";
+    case "discovered_issue":
+      return event.issue
+        ? `Created follow-up task ${event.taskId}: ${event.issue}`
+        : `Created follow-up task ${event.taskId} for discovered issue`;
+    case "research_dispatch":
+      return event.target && event.researchType
+        ? `Dispatched ${event.researchType} research to ${event.target}`
+        : `Dispatched research task ${event.taskId}`;
+    case "research_finding":
+      return event.summary && event.researchType
+        ? `Research finding (${event.researchType}): ${event.summary}`
+        : `Recorded research finding from task ${event.taskId}`;
+    default:
+      return (
+        (event as { message?: string }).message ?? `Event: ${(event as { type: string }).type}`
+      );
+  }
+}
+
+const MAX_LOG_SIZE = 1048576; // 1MB
+let _rotating = false;
+
+export function appendEvent(dir: string, event: OrchestratorEvent | StructuredEvent): void {
+  const tasksDir = join(dir, ".tasks");
+  if (!existsSync(tasksDir)) {
+    mkdirSync(tasksDir, { recursive: true });
+  }
+  const logPath = join(tasksDir, "events.log");
+
+  // Rotate if file exceeds 1MB (atomic: copy to temp, rename temp to .1, remove old)
+  // Guard with _rotating flag to prevent concurrent rotation from interleaved calls
+  if (!_rotating && existsSync(logPath)) {
+    try {
+      const size = statSync(logPath).size;
+      if (size > MAX_LOG_SIZE) {
+        _rotating = true;
+        const rotatedPath = logPath + ".1";
+        const tmpRotated = rotatedPath + ".tmp";
+        copyFileSync(logPath, tmpRotated);
+        renameSync(tmpRotated, rotatedPath);
+        unlinkSync(logPath);
+      }
+    } catch {
+      // stat/copy/rename failure — continue writing to current file
+    } finally {
+      _rotating = false;
+    }
+  }
+
+  const line = JSON.stringify(event) + "\n";
+
+  // If it's a structured event (no message field, or error type with typed payload),
+  // validate with schema before writing
+  if (!("message" in event) || StructuredEventSchemaZ.safeParse(event).success) {
+    appendFileSync(logPath, line);
+    if (_webhooks.length > 0) fireWebhooks(_webhooks, event);
+    return;
+  }
+
+  // Old-format event with free-form message — write as-is
+  appendFileSync(logPath, line);
+  if (_webhooks.length > 0) fireWebhooks(_webhooks, event);
+}
+
+export function readEvents(dir: string): OrchestratorEvent[] {
+  const logPath = join(dir, ".tasks", "events.log");
+  const rotatedPath = logPath + ".1";
+
+  // Collect lines from rotated file first (older events), then current
+  let lines: string[] = [];
+  if (existsSync(rotatedPath)) {
+    const raw = readFileSync(rotatedPath, "utf-8").trim();
+    if (raw) lines = raw.split("\n");
+  }
+  if (existsSync(logPath)) {
+    const raw = readFileSync(logPath, "utf-8").trim();
+    if (raw) lines = lines.concat(raw.split("\n"));
+  }
+  if (lines.length === 0) return [];
+
+  return lines
+    .map((line) => {
+      try {
+        const parsed = JSON.parse(line);
+
+        // Old format: has a message field → return as-is
+        if ("message" in parsed && typeof parsed.message === "string") {
+          return parsed as OrchestratorEvent;
+        }
+
+        // New structured format: try to parse and generate message
+        const result = StructuredEventSchemaZ.safeParse(parsed);
+        if (result.success) {
+          const structured = result.data;
+          return {
+            timestamp: structured.timestamp,
+            type: structured.type,
+            taskId: "taskId" in structured ? structured.taskId : undefined,
+            agent: "agent" in structured ? structured.agent : undefined,
+            message: formatEventMessage(structured),
+          } as OrchestratorEvent;
+        }
+
+        // Fallback: treat as old format if it has at minimum type and timestamp
+        if (parsed.type && parsed.timestamp) {
+          return { ...parsed, message: parsed.message ?? "" } as OrchestratorEvent;
+        }
+
+        return null;
+      } catch {
+        return null;
+      }
+    })
+    .filter((e): e is OrchestratorEvent => e !== null);
+}

package/src/lib/github-pr.ts

@@ -0,0 +1,182 @@
+import { execFileSync } from "node:child_process";
+import type { Task, Mission } from "./task-store.ts";
+import type { ProofSchema } from "../types.ts";
+
+export interface PrResult {
+  url: string;
+  number: number;
+}
+
+/**
+ * Check if the gh CLI is available.
+ */
+export function isGhAvailable(): boolean {
+  try {
+    execFileSync("gh", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a GitHub PR for a completed task.
+ * Returns the PR URL and number, or null if creation failed.
+ */
+export function createTaskPr(task: Task, cwd: string, baseBranch?: string): PrResult | null {
+  // Determine the current branch
+  let headBranch: string;
+  try {
+    headBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+
+  // Build PR body
+  const bodyParts: string[] = [];
+  if (task.description) bodyParts.push(task.description);
+  if (task.proof) {
+    bodyParts.push("");
+    bodyParts.push("## Proof");
+    const proof = task.proof as ProofSchema;
+    if (proof.notes) bodyParts.push(proof.notes);
+    if (proof.tests) bodyParts.push(`Tests: ${proof.tests.passed}/${proof.tests.total} passed`);
+    if (proof.ci)
+      bodyParts.push(`CI: ${proof.ci.status}${proof.ci.url ? ` (${proof.ci.url})` : ""}`);
+  }
+  if (task.tags.length > 0) {
+    bodyParts.push("");
+    bodyParts.push(`Tags: ${task.tags.join(", ")}`);
+  }
+
+  const title = `Task ${task.id}: ${task.title}`;
+  const body = bodyParts.join("\n") || task.title;
+
+  try {
+    // Push the branch first (gh pr create needs it on remote)
+    try {
+      execFileSync("git", ["push", "-u", "origin", headBranch], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch {
+      // Branch may already be pushed, or remote may not exist — continue anyway
+    }
+
+    // Create the PR
+    const output = execFileSync(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--title",
+        title,
+        "--body",
+        body,
+        "--head",
+        headBranch,
+        ...(baseBranch ? ["--base", baseBranch] : []),
+      ],
+      {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    ).trim();
+
+    // gh pr create outputs the PR URL
+    const url = output;
+    // Extract PR number from URL (e.g. https://github.com/owner/repo/pull/42)
+    const match = url.match(/\/pull\/(\d+)/);
+    const number = match ? parseInt(match[1]!, 10) : 0;
+
+    return { url, number };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a GitHub PR for a completed mission.
+ * Uses mission.branch as head; if not set, uses current branch.
+ */
+export function createMissionPr(
+  mission: Mission,
+  cwd: string,
+  baseBranch?: string,
+): PrResult | null {
+  let headBranch: string;
+  if (mission.branch) {
+    headBranch = mission.branch;
+  } else {
+    try {
+      headBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+    } catch {
+      return null;
+    }
+  }
+
+  const milestonesSummary = mission.milestones
+    .sort((a, b) => a.order - b.order)
+    .map((m) => `- ${m.id}: ${m.title} [${m.status}]`)
+    .join("\n");
+
+  const title = `Mission: ${mission.title}`;
+  const bodyParts: string[] = [];
+  if (mission.description) bodyParts.push(mission.description);
+  bodyParts.push("");
+  bodyParts.push("## Milestones");
+  bodyParts.push(milestonesSummary || "No milestones");
+  const body = bodyParts.join("\n");
+
+  try {
+    try {
+      execFileSync("git", ["push", "-u", "origin", headBranch], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch {
+      // Branch may already be pushed
+    }
+
+    const output = execFileSync(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--title",
+        title,
+        "--body",
+        body,
+        "--head",
+        headBranch,
+        ...(baseBranch ? ["--base", baseBranch] : []),
+      ],
+      {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    ).trim();
+
+    const url = output;
+    const match = url.match(/\/pull\/(\d+)/);
+    const number = match ? parseInt(match[1]!, 10) : 0;
+    return { url, number };
+  } catch {
+    return null;
+  }
+}