style: fix formatting with Prettier

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

apps/server/tests/unit/lib/events.test.ts

@@ -1,20 +1,20 @@
-import { describe, it, expect, vi } from "vitest";
-import { createEventEmitter, type EventType } from "@/lib/events.js";
+import { describe, it, expect, vi } from 'vitest';
+import { createEventEmitter, type EventType } from '@/lib/events.js';
 
-describe("events.ts", () => {
-  describe("createEventEmitter", () => {
-    it("should emit events to single subscriber", () => {
+describe('events.ts', () => {
+  describe('createEventEmitter', () => {
+    it('should emit events to single subscriber', () => {
       const emitter = createEventEmitter();
       const callback = vi.fn();
 
       emitter.subscribe(callback);
-      emitter.emit("agent:stream", { message: "test" });
+      emitter.emit('agent:stream', { message: 'test' });
 
       expect(callback).toHaveBeenCalledOnce();
-      expect(callback).toHaveBeenCalledWith("agent:stream", { message: "test" });
+      expect(callback).toHaveBeenCalledWith('agent:stream', { message: 'test' });
     });
 
-    it("should emit events to multiple subscribers", () => {
+    it('should emit events to multiple subscribers', () => {
       const emitter = createEventEmitter();
       const callback1 = vi.fn();
       const callback2 = vi.fn();
@@ -23,42 +23,42 @@ describe("events.ts", () => {
       emitter.subscribe(callback1);
       emitter.subscribe(callback2);
       emitter.subscribe(callback3);
-      emitter.emit("feature:started", { id: "123" });
+      emitter.emit('feature:started', { id: '123' });
 
       expect(callback1).toHaveBeenCalledOnce();
       expect(callback2).toHaveBeenCalledOnce();
       expect(callback3).toHaveBeenCalledOnce();
-      expect(callback1).toHaveBeenCalledWith("feature:started", { id: "123" });
+      expect(callback1).toHaveBeenCalledWith('feature:started', { id: '123' });
     });
 
-    it("should support unsubscribe functionality", () => {
+    it('should support unsubscribe functionality', () => {
       const emitter = createEventEmitter();
       const callback = vi.fn();
 
       const unsubscribe = emitter.subscribe(callback);
-      emitter.emit("agent:stream", { test: 1 });
+      emitter.emit('agent:stream', { test: 1 });
 
       expect(callback).toHaveBeenCalledOnce();
 
       unsubscribe();
-      emitter.emit("agent:stream", { test: 2 });
+      emitter.emit('agent:stream', { test: 2 });
 
       expect(callback).toHaveBeenCalledOnce(); // Still called only once
     });
 
-    it("should handle errors in subscribers without crashing", () => {
+    it('should handle errors in subscribers without crashing', () => {
       const emitter = createEventEmitter();
       const errorCallback = vi.fn(() => {
-        throw new Error("Subscriber error");
+        throw new Error('Subscriber error');
       });
       const normalCallback = vi.fn();
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       emitter.subscribe(errorCallback);
       emitter.subscribe(normalCallback);
 
       expect(() => {
-        emitter.emit("feature:error", { error: "test" });
+        emitter.emit('feature:error', { error: 'test' });
       }).not.toThrow();
 
       expect(errorCallback).toHaveBeenCalledOnce();
@@ -68,17 +68,17 @@ describe("events.ts", () => {
       consoleSpy.mockRestore();
     });
 
-    it("should emit different event types", () => {
+    it('should emit different event types', () => {
       const emitter = createEventEmitter();
       const callback = vi.fn();
 
       emitter.subscribe(callback);
 
       const eventTypes: EventType[] = [
-        "agent:stream",
-        "auto-mode:started",
-        "feature:completed",
-        "project:analysis-progress",
+        'agent:stream',
+        'auto-mode:started',
+        'feature:completed',
+        'project:analysis-progress',
       ];
 
       eventTypes.forEach((type) => {
@@ -88,15 +88,15 @@ describe("events.ts", () => {
       expect(callback).toHaveBeenCalledTimes(4);
     });
 
-    it("should handle emitting without subscribers", () => {
+    it('should handle emitting without subscribers', () => {
       const emitter = createEventEmitter();
 
       expect(() => {
-        emitter.emit("agent:stream", { test: true });
+        emitter.emit('agent:stream', { test: true });
       }).not.toThrow();
     });
 
-    it("should allow multiple subscriptions and unsubscriptions", () => {
+    it('should allow multiple subscriptions and unsubscriptions', () => {
       const emitter = createEventEmitter();
       const callback1 = vi.fn();
       const callback2 = vi.fn();
@@ -106,14 +106,14 @@ describe("events.ts", () => {
       const unsub2 = emitter.subscribe(callback2);
       const unsub3 = emitter.subscribe(callback3);
 
-      emitter.emit("feature:started", { test: 1 });
+      emitter.emit('feature:started', { test: 1 });
       expect(callback1).toHaveBeenCalledOnce();
       expect(callback2).toHaveBeenCalledOnce();
       expect(callback3).toHaveBeenCalledOnce();
 
       unsub2();
 
-      emitter.emit("feature:started", { test: 2 });
+      emitter.emit('feature:started', { test: 2 });
       expect(callback1).toHaveBeenCalledTimes(2);
       expect(callback2).toHaveBeenCalledOnce(); // Still just once
       expect(callback3).toHaveBeenCalledTimes(2);
@@ -121,7 +121,7 @@ describe("events.ts", () => {
       unsub1();
       unsub3();
 
-      emitter.emit("feature:started", { test: 3 });
+      emitter.emit('feature:started', { test: 3 });
       expect(callback1).toHaveBeenCalledTimes(2);
       expect(callback2).toHaveBeenCalledOnce();
       expect(callback3).toHaveBeenCalledTimes(2);