chore(#1): apply Prettier formatting to all source and test files

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/queue.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { EventQueue } from '../src/queue.js';
+import { describe, it, expect } from "vitest";
+import { EventQueue } from "../src/queue.js";
 import {
   TaskType,
   Complexity,
@@ -7,19 +7,19 @@ import {
   Provider,
   Outcome,
   TaskCompletionEvent,
-} from '../src/types/events.js';
+} from "../src/types/events.js";
 
 function makeEvent(id: string): TaskCompletionEvent {
   return {
-    instance_id: 'test-instance',
+    instance_id: "test-instance",
     event_id: id,
-    schema_version: '1.0',
+    schema_version: "1.0",
     timestamp: new Date().toISOString(),
     task_duration_ms: 1000,
     task_type: TaskType.IMPLEMENTATION,
     complexity: Complexity.MEDIUM,
     harness: Harness.CLAUDE_CODE,
-    model: 'claude-3-opus',
+    model: "claude-3-opus",
     provider: Provider.ANTHROPIC,
     estimated_input_tokens: 1000,
     estimated_output_tokens: 500,
@@ -38,10 +38,10 @@ function makeEvent(id: string): TaskCompletionEvent {
   };
 }
 
-describe('EventQueue', () => {
-  it('should enqueue and drain events', () => {
+describe("EventQueue", () => {
+  it("should enqueue and drain events", () => {
     const queue = new EventQueue(10);
-    const event = makeEvent('e1');
+    const event = makeEvent("e1");
 
     queue.enqueue(event);
     expect(queue.size).toBe(1);
@@ -49,102 +49,102 @@ describe('EventQueue', () => {
 
     const drained = queue.drain(10);
     expect(drained).toHaveLength(1);
-    expect(drained[0].event_id).toBe('e1');
+    expect(drained[0].event_id).toBe("e1");
     expect(queue.isEmpty).toBe(true);
   });
 
-  it('should respect maxSize with FIFO eviction', () => {
+  it("should respect maxSize with FIFO eviction", () => {
     const queue = new EventQueue(3);
 
-    queue.enqueue(makeEvent('e1'));
-    queue.enqueue(makeEvent('e2'));
-    queue.enqueue(makeEvent('e3'));
+    queue.enqueue(makeEvent("e1"));
+    queue.enqueue(makeEvent("e2"));
+    queue.enqueue(makeEvent("e3"));
     expect(queue.size).toBe(3);
 
     // Adding a 4th should evict the oldest (e1)
-    queue.enqueue(makeEvent('e4'));
+    queue.enqueue(makeEvent("e4"));
     expect(queue.size).toBe(3);
 
     const drained = queue.drain(10);
-    expect(drained.map((e) => e.event_id)).toEqual(['e2', 'e3', 'e4']);
+    expect(drained.map((e) => e.event_id)).toEqual(["e2", "e3", "e4"]);
   });
 
-  it('should drain up to maxItems', () => {
+  it("should drain up to maxItems", () => {
     const queue = new EventQueue(10);
-    queue.enqueue(makeEvent('e1'));
-    queue.enqueue(makeEvent('e2'));
-    queue.enqueue(makeEvent('e3'));
+    queue.enqueue(makeEvent("e1"));
+    queue.enqueue(makeEvent("e2"));
+    queue.enqueue(makeEvent("e3"));
 
     const drained = queue.drain(2);
     expect(drained).toHaveLength(2);
-    expect(drained.map((e) => e.event_id)).toEqual(['e1', 'e2']);
+    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e2"]);
     expect(queue.size).toBe(1);
   });
 
-  it('should remove drained items from the queue', () => {
+  it("should remove drained items from the queue", () => {
     const queue = new EventQueue(10);
-    queue.enqueue(makeEvent('e1'));
-    queue.enqueue(makeEvent('e2'));
+    queue.enqueue(makeEvent("e1"));
+    queue.enqueue(makeEvent("e2"));
 
     queue.drain(1);
     expect(queue.size).toBe(1);
 
     const remaining = queue.drain(10);
-    expect(remaining[0].event_id).toBe('e2');
+    expect(remaining[0].event_id).toBe("e2");
   });
 
-  it('should report isEmpty correctly', () => {
+  it("should report isEmpty correctly", () => {
     const queue = new EventQueue(5);
     expect(queue.isEmpty).toBe(true);
 
-    queue.enqueue(makeEvent('e1'));
+    queue.enqueue(makeEvent("e1"));
     expect(queue.isEmpty).toBe(false);
 
     queue.drain(1);
     expect(queue.isEmpty).toBe(true);
   });
 
-  it('should report size correctly', () => {
+  it("should report size correctly", () => {
     const queue = new EventQueue(10);
     expect(queue.size).toBe(0);
 
-    queue.enqueue(makeEvent('e1'));
+    queue.enqueue(makeEvent("e1"));
     expect(queue.size).toBe(1);
 
-    queue.enqueue(makeEvent('e2'));
+    queue.enqueue(makeEvent("e2"));
     expect(queue.size).toBe(2);
 
     queue.drain(1);
     expect(queue.size).toBe(1);
   });
 
-  it('should return empty array when draining empty queue', () => {
+  it("should return empty array when draining empty queue", () => {
     const queue = new EventQueue(5);
     const drained = queue.drain(10);
     expect(drained).toEqual([]);
   });
 
-  it('should prepend events to the front of the queue', () => {
+  it("should prepend events to the front of the queue", () => {
     const queue = new EventQueue(10);
-    queue.enqueue(makeEvent('e3'));
+    queue.enqueue(makeEvent("e3"));
 
-    queue.prepend([makeEvent('e1'), makeEvent('e2')]);
+    queue.prepend([makeEvent("e1"), makeEvent("e2")]);
     expect(queue.size).toBe(3);
 
     const drained = queue.drain(10);
-    expect(drained.map((e) => e.event_id)).toEqual(['e1', 'e2', 'e3']);
+    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e2", "e3"]);
   });
 
-  it('should respect maxSize when prepending', () => {
+  it("should respect maxSize when prepending", () => {
     const queue = new EventQueue(3);
-    queue.enqueue(makeEvent('e3'));
-    queue.enqueue(makeEvent('e4'));
+    queue.enqueue(makeEvent("e3"));
+    queue.enqueue(makeEvent("e4"));
 
     // Only 1 slot available, so only first event should be prepended
-    queue.prepend([makeEvent('e1'), makeEvent('e2')]);
+    queue.prepend([makeEvent("e1"), makeEvent("e2")]);
     expect(queue.size).toBe(3);
 
     const drained = queue.drain(10);
-    expect(drained.map((e) => e.event_id)).toEqual(['e1', 'e3', 'e4']);
+    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e3", "e4"]);
   });
 });