maskweaver 0.9.3 → 0.9.5

package/dist/shared-context/test/session.test.js

@@ -1,10 +1,3 @@
-/**
- * Session Management Tests
- *
- * "Make it work, make it right, make it fast." - Kent Beck
- *
- * Red-Green-Refactor cycle for session.ts
- */
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { mkdtemp, rm } from "fs/promises";
 import { existsSync } from "fs";
@@ -16,80 +9,59 @@ describe("Session Management", () => {
     let tempDir;
     let storage;
     beforeEach(async () => {
-        // 각 테스트마다 깨끗한 임시 디렉토리 생성
         tempDir = await mkdtemp(join(tmpdir(), "session-test-"));
         storage = new FileStorageAdapter(tempDir);
     });
     afterEach(async () => {
-        // 테스트 후 정리
         await rm(tempDir, { recursive: true, force: true });
     });
-    // ==========================================================================
-    // createSession Tests
-    // ==========================================================================
     describe("createSession", () => {
         test("should generate UUID format sessionId", async () => {
-            // Arrange
             const options = {
                 goal: "Test goal",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert - UUID v4 format: 8-4-4-4-12 hex characters
             const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
             expect(session.manifest.sessionId).toMatch(uuidRegex);
         });
         test("should create manifest.json file", async () => {
-            // Arrange
             const options = {
                 goal: "Build feature X",
                 createdBy: "operator-1",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             const manifestPath = join(tempDir, "shared", session.manifest.sessionId, "manifest.json");
             expect(existsSync(manifestPath)).toBe(true);
         });
         test("should create events/ directory", async () => {
-            // Arrange
             const options = {
                 goal: "Test events dir",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             const eventsPath = join(tempDir, "shared", session.manifest.sessionId, "events");
             expect(existsSync(eventsPath)).toBe(true);
         });
         test("should create squads/ directory", async () => {
-            // Arrange
             const options = {
                 goal: "Test squads dir",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             const squadsPath = join(tempDir, "shared", session.manifest.sessionId, "squads");
             expect(existsSync(squadsPath)).toBe(true);
         });
         test("should store goal and createdBy in manifest", async () => {
-            // Arrange
             const options = {
                 goal: "Implement user authentication",
                 createdBy: "orchestrator-alpha",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             expect(session.manifest.goal).toBe("Implement user authentication");
             expect(session.manifest.createdBy).toBe("orchestrator-alpha");
         });
         test("should store constraints in manifest when provided", async () => {
-            // Arrange
             const options = {
                 goal: "Time-boxed task",
                 createdBy: "test-agent",
@@ -98,62 +70,47 @@ describe("Session Management", () => {
                     tokenBudget: 50000,
                 },
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             expect(session.manifest.constraints).toBeDefined();
             expect(session.manifest.constraints?.timeout).toBe("30m");
             expect(session.manifest.constraints?.tokenBudget).toBe(50000);
         });
         test("should initialize version to 1", async () => {
-            // Arrange
             const options = {
                 goal: "Test version",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             expect(session.manifest.version).toBe(1);
         });
         test("should initialize squads as empty array", async () => {
-            // Arrange
             const options = {
                 goal: "Test squads init",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             expect(session.manifest.squads).toEqual([]);
         });
         test("should set createdAt as ISO timestamp", async () => {
-            // Arrange
             const beforeCreate = new Date().toISOString();
             const options = {
                 goal: "Test timestamp",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
             const afterCreate = new Date().toISOString();
-            // Assert - createdAt should be between before and after
             expect(session.manifest.createdAt >= beforeCreate).toBe(true);
             expect(session.manifest.createdAt <= afterCreate).toBe(true);
         });
         test("should return correct sessionPath", async () => {
-            // Arrange
             const options = {
                 goal: "Test session path",
                 createdBy: "test-agent",
             };
-            // Act
             const session = await createSession(storage, options);
-            // Assert
             expect(session.sessionPath).toBe(`shared/${session.manifest.sessionId}`);
         });
         test("should persist manifest that can be read back", async () => {
-            // Arrange
             const options = {
                 goal: "Persistence test",
                 createdBy: "test-agent",
@@ -161,57 +118,42 @@ describe("Session Management", () => {
                     timeout: "1h",
                 },
             };
-            // Act
             const session = await createSession(storage, options);
             const readManifest = await storage.read(`${session.sessionPath}/manifest.json`);
-            // Assert
             expect(readManifest).not.toBeNull();
             expect(readManifest?.sessionId).toBe(session.manifest.sessionId);
             expect(readManifest?.goal).toBe("Persistence test");
             expect(readManifest?.constraints?.timeout).toBe("1h");
         });
     });
-    // ==========================================================================
-    // loadSession Tests
-    // ==========================================================================
     describe("loadSession", () => {
         test("should load existing session successfully", async () => {
-            // Arrange - 먼저 세션 생성
             const options = {
                 goal: "Load test",
                 createdBy: "creator-agent",
             };
             const created = await createSession(storage, options);
-            // Act - 세션 로드
             const loaded = await loadSession(storage, created.manifest.sessionId);
-            // Assert
             expect(loaded).not.toBeNull();
             expect(loaded?.manifest.sessionId).toBe(created.manifest.sessionId);
             expect(loaded?.manifest.goal).toBe("Load test");
             expect(loaded?.manifest.createdBy).toBe("creator-agent");
         });
         test("should return null for non-existent session", async () => {
-            // Arrange - 존재하지 않는 sessionId
             const fakeSessionId = "00000000-0000-0000-0000-000000000000";
-            // Act
             const result = await loadSession(storage, fakeSessionId);
-            // Assert
             expect(result).toBeNull();
         });
         test("should return correct sessionPath", async () => {
-            // Arrange
             const options = {
                 goal: "Path test",
                 createdBy: "test-agent",
             };
             const created = await createSession(storage, options);
-            // Act
             const loaded = await loadSession(storage, created.manifest.sessionId);
-            // Assert
             expect(loaded?.sessionPath).toBe(`shared/${created.manifest.sessionId}`);
         });
         test("should load session with constraints", async () => {
-            // Arrange
             const options = {
                 goal: "Constraints load test",
                 createdBy: "test-agent",
@@ -221,22 +163,17 @@ describe("Session Management", () => {
                 },
             };
             const created = await createSession(storage, options);
-            // Act
             const loaded = await loadSession(storage, created.manifest.sessionId);
-            // Assert
             expect(loaded?.manifest.constraints?.timeout).toBe("2h");
             expect(loaded?.manifest.constraints?.tokenBudget).toBe(100000);
         });
         test("should return storage adapter reference", async () => {
-            // Arrange
             const options = {
                 goal: "Storage ref test",
                 createdBy: "test-agent",
             };
             const created = await createSession(storage, options);
-            // Act
             const loaded = await loadSession(storage, created.manifest.sessionId);
-            // Assert
             expect(loaded?.storage).toBe(storage);
         });
     });

package/dist/shared-context/test/squad.test.d.ts

@@ -1,11 +1 @@
-/**
- * Squad Management Tests
- *
- * Kent Beck의 TDD 원칙:
- * - 작고 명확한 테스트
- * - 하나의 테스트는 하나의 행동만 검증
- * - Red-Green-Refactor 사이클
- *
- * @author Kent Beck's Dummy Human
- */
 export {};

package/dist/shared-context/test/squad.test.js

@@ -1,13 +1,3 @@
-/**
- * Squad Management Tests
- *
- * Kent Beck의 TDD 원칙:
- * - 작고 명확한 테스트
- * - 하나의 테스트는 하나의 행동만 검증
- * - Red-Green-Refactor 사이클
- *
- * @author Kent Beck's Dummy Human
- */
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
@@ -17,14 +7,10 @@ import { FileStorageAdapter } from "../storage.js";
 import { createSession } from "../session.js";
 import { createSquad, getSquad, updateSquadState } from "../squad.js";
 import { LIMITS } from "../types.js";
-// ============================================================================
-// Test Fixtures
-// ============================================================================
 let tempDir;
 let storage;
 let session;
 beforeEach(async () => {
-    // Arrange: 각 테스트 전에 깨끗한 임시 디렉토리 생성
     tempDir = await mkdtemp(join(tmpdir(), "squad-test-"));
     storage = new FileStorageAdapter(tempDir);
     session = await createSession(storage, {
@@ -33,48 +19,37 @@ beforeEach(async () => {
     });
 });
 afterEach(async () => {
-    // Cleanup: 테스트 후 임시 디렉토리 정리
     if (tempDir && existsSync(tempDir)) {
         await rm(tempDir, { recursive: true, force: true });
     }
 });
-// ============================================================================
-// createSquad Tests
-// ============================================================================
 describe("createSquad", () => {
     test("should create spec.json and state.json files", async () => {
-        // Act
         const { spec, state } = await createSquad(session, {
             mission: "Implement feature X",
             operator: "operator-agent",
         });
-        // Assert: 파일 생성 확인
         const squadPath = `${session.sessionPath}/squads/${spec.squadId}`;
         expect(storage.exists(`${squadPath}/spec.json`)).toBe(true);
         expect(storage.exists(`${squadPath}/state.json`)).toBe(true);
     });
     test("should add squadId to manifest.squads array", async () => {
-        // Act
         const { spec } = await createSquad(session, {
             mission: "Implement feature X",
             operator: "operator-agent",
         });
-        // Assert: manifest에 squadId 추가 확인
         expect(session.manifest.squads).toContain(spec.squadId);
         expect(session.manifest.squads.length).toBe(1);
     });
     test("should create scratch/ directory", async () => {
-        // Act
         const { spec } = await createSquad(session, {
             mission: "Implement feature X",
             operator: "operator-agent",
         });
-        // Assert: scratch 디렉토리 생성 확인
         const scratchPath = `${session.sessionPath}/squads/${spec.squadId}/scratch`;
         expect(existsSync(storage.getFullPath(scratchPath))).toBe(true);
     });
     test("should return spec with correct properties", async () => {
-        // Arrange
         const options = {
             mission: "Implement OAuth login",
             operator: "operator-alpha",
@@ -88,9 +63,7 @@ describe("createSquad", () => {
                 directories: ["src/auth/"],
             },
         };
-        // Act
         const { spec } = await createSquad(session, options);
-        // Assert: spec 속성 검증
         expect(spec.squadId).toMatch(/^squad-[a-f0-9]{8}$/);
         expect(spec.mission).toBe(options.mission);
         expect(spec.operator).toBe(options.operator);
@@ -101,12 +74,10 @@ describe("createSquad", () => {
         expect(spec.createdAt).toBeDefined();
     });
     test("should return state with initial values", async () => {
-        // Act
         const { state } = await createSquad(session, {
             mission: "Test mission",
             operator: "operator",
         });
-        // Assert: 초기 상태 검증
         expect(state.status).toBe("pending");
         expect(state.progress).toBe(0);
         expect(state.tasks).toEqual([]);
@@ -114,35 +85,29 @@ describe("createSquad", () => {
         expect(state.updatedAt).toBeDefined();
     });
     test("should use default maxWorkers from LIMITS when not specified", async () => {
-        // Act
         const { spec } = await createSquad(session, {
             mission: "Test mission",
             operator: "operator",
         });
-        // Assert
         expect(spec.constraints?.maxWorkers).toBe(LIMITS.maxWorkersPerSquad);
     });
     test("should throw error when maxSquadsPerSession limit is reached", async () => {
-        // Arrange: 최대 개수만큼 Squad 생성
         for (let i = 0; i < LIMITS.maxSquadsPerSession; i++) {
             await createSquad(session, {
                 mission: `Mission ${i}`,
                 operator: "operator",
             });
         }
-        // Act & Assert: 한도 초과 시 에러
         await expect(createSquad(session, {
             mission: "One too many",
             operator: "operator",
         })).rejects.toThrow("Maximum squads per session exceeded");
     });
     test("should persist spec.json with correct data", async () => {
-        // Act
         const { spec } = await createSquad(session, {
             mission: "Persisted mission",
             operator: "persistent-operator",
         });
-        // Assert: 파일에서 직접 읽어서 검증
         const squadPath = `${session.sessionPath}/squads/${spec.squadId}`;
         const savedSpec = await storage.read(`${squadPath}/spec.json`);
         expect(savedSpec).not.toBeNull();
@@ -150,129 +115,98 @@ describe("createSquad", () => {
         expect(savedSpec?.operator).toBe("persistent-operator");
     });
 });
-// ============================================================================
-// getSquad Tests
-// ============================================================================
 describe("getSquad", () => {
     test("should return squad when it exists", async () => {
-        // Arrange
         const created = await createSquad(session, {
             mission: "Find me",
             operator: "operator",
         });
-        // Act
         const retrieved = await getSquad(session, created.spec.squadId);
-        // Assert
         expect(retrieved).not.toBeNull();
         expect(retrieved?.spec.squadId).toBe(created.spec.squadId);
         expect(retrieved?.spec.mission).toBe("Find me");
         expect(retrieved?.state.status).toBe("pending");
     });
     test("should return null when squad does not exist", async () => {
-        // Act
         const result = await getSquad(session, "squad-nonexistent");
-        // Assert
         expect(result).toBeNull();
     });
     test("should return both spec and state", async () => {
-        // Arrange
         const created = await createSquad(session, {
             mission: "Dual return test",
             operator: "operator",
         });
-        // Act
         const result = await getSquad(session, created.spec.squadId);
-        // Assert
         expect(result).toHaveProperty("spec");
         expect(result).toHaveProperty("state");
         expect(result?.spec.squadId).toBe(result?.state.squadId);
     });
 });
-// ============================================================================
-// updateSquadState Tests
-// ============================================================================
 describe("updateSquadState", () => {
     test("should update state and reflect changes on subsequent get", async () => {
-        // Arrange
         const { spec } = await createSquad(session, {
             mission: "Update me",
             operator: "operator",
         });
-        // Act
         await updateSquadState(session, spec.squadId, {
             status: "active",
             progress: 50,
         });
-        // Assert: 업데이트된 값 확인
         const retrieved = await getSquad(session, spec.squadId);
         expect(retrieved?.state.status).toBe("active");
         expect(retrieved?.state.progress).toBe(50);
     });
     test("should automatically update updatedAt timestamp", async () => {
-        // Arrange
         const { spec, state: initialState } = await createSquad(session, {
             mission: "Timestamp test",
             operator: "operator",
         });
         const initialUpdatedAt = initialState.updatedAt;
-        // 시간 차이를 위해 약간 대기
         await new Promise((resolve) => setTimeout(resolve, 10));
-        // Act
         const updatedState = await updateSquadState(session, spec.squadId, {
             progress: 25,
         });
-        // Assert: updatedAt이 갱신됨
         expect(updatedState.updatedAt).not.toBe(initialUpdatedAt);
         expect(new Date(updatedState.updatedAt).getTime()).toBeGreaterThan(new Date(initialUpdatedAt).getTime());
     });
     test("should throw error when squad does not exist", async () => {
-        // Act & Assert
         await expect(updateSquadState(session, "squad-nonexistent", { status: "active" })).rejects.toThrow("Squad not found: squad-nonexistent");
     });
     test("should preserve unmodified fields", async () => {
-        // Arrange
         const { spec } = await createSquad(session, {
             mission: "Preserve fields",
             operator: "operator",
         });
-        // Act: status만 업데이트
         await updateSquadState(session, spec.squadId, { status: "active" });
-        // Assert: 다른 필드는 유지
         const retrieved = await getSquad(session, spec.squadId);
         expect(retrieved?.state.status).toBe("active");
-        expect(retrieved?.state.progress).toBe(0); // 초기값 유지
-        expect(retrieved?.state.tasks).toEqual([]); // 초기값 유지
+        expect(retrieved?.state.progress).toBe(0);
+        expect(retrieved?.state.tasks).toEqual([]);
     });
     test("should return the updated state", async () => {
-        // Arrange
         const { spec } = await createSquad(session, {
             mission: "Return value test",
             operator: "operator",
         });
-        // Act
         const result = await updateSquadState(session, spec.squadId, {
             status: "completed",
             progress: 100,
         });
-        // Assert
         expect(result.status).toBe("completed");
         expect(result.progress).toBe(100);
         expect(result.squadId).toBe(spec.squadId);
     });
     test("should update sharedContext", async () => {
-        // Arrange
         const { spec } = await createSquad(session, {
             mission: "Shared context test",
             operator: "operator",
         });
-        // Act
         await updateSquadState(session, spec.squadId, {
             sharedContext: {
                 apiEndpoint: "https://api.example.com",
                 authToken: "secret",
             },
         });
-        // Assert
         const retrieved = await getSquad(session, spec.squadId);
         expect(retrieved?.state.sharedContext).toEqual({
             apiEndpoint: "https://api.example.com",

package/dist/shared-context/test/storage.test.d.ts

@@ -1,9 +1 @@
-/**
- * Storage Adapter Unit Tests
- *
- * "First make it work, then make it right, then make it fast."
- * - Kent Beck
- *
- * @author Kent Beck's Dummy Human
- */
 export {};