whale-code 6.5.4 → 6.5.6

package/dist/cli/services/team-state.js

@@ -7,392 +7,392 @@
  * - Inter-agent message queue
  * - Dependencies between tasks
  */
+
 import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
+import { TEAMS_DIR, ensureDataDir } from "./paths.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
 // ============================================================================
 // STORAGE
 // ============================================================================
-const TEAMS_DIR = join(homedir(), ".swagmanager", "teams");
+
 function ensureTeamsDir() {
-    if (!existsSync(TEAMS_DIR)) {
-        mkdirSync(TEAMS_DIR, { recursive: true });
-    }
+  ensureDataDir();
+  if (!existsSync(TEAMS_DIR)) {
+    mkdirSync(TEAMS_DIR, {
+      recursive: true
+    });
+  }
 }
 function getTeamPath(teamId) {
-    return join(TEAMS_DIR, `${teamId}.json`);
+  return join(TEAMS_DIR, `${teamId}.json`);
 }
 function getLockPath(teamId) {
-    return join(TEAMS_DIR, `${teamId}.lock`);
+  return join(TEAMS_DIR, `${teamId}.lock`);
 }
+
 // ============================================================================
 // FILE LOCKING — Prevents concurrent modifications
 // ============================================================================
+
 const LOCK_TIMEOUT_MS = 5000;
 const LOCK_RETRY_MS = 50;
 async function acquireLock(teamId) {
-    const lockPath = getLockPath(teamId);
-    const startTime = Date.now();
-    while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
-        try {
-            // Check if lock exists and is stale
-            if (existsSync(lockPath)) {
-                const lockData = readFileSync(lockPath, "utf-8");
-                const lockTime = parseInt(lockData, 10);
-                if (Date.now() - lockTime > LOCK_TIMEOUT_MS) {
-                    // Stale lock, remove it
-                    unlinkSync(lockPath);
-                }
-                else {
-                    // Valid lock, wait and retry
-                    await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
-                    continue;
-                }
-            }
-            // Try to create lock
-            writeFileSync(lockPath, Date.now().toString(), { flag: "wx" });
-            return true;
-        }
-        catch (err) {
-            if (err.code === "EEXIST") {
-                // Lock was created by another process, retry
-                await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
-                continue;
-            }
-            throw err;
+  const lockPath = getLockPath(teamId);
+  const startTime = Date.now();
+  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+    try {
+      // Check if lock exists and is stale
+      if (existsSync(lockPath)) {
+        const lockData = readFileSync(lockPath, "utf-8");
+        const lockTime = parseInt(lockData, 10);
+        if (Date.now() - lockTime > LOCK_TIMEOUT_MS) {
+          // Stale lock, remove it
+          unlinkSync(lockPath);
+        } else {
+          // Valid lock, wait and retry
+          await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
+          continue;
         }
-    }
-    return false;
+      }
+
+      // Try to create lock
+      writeFileSync(lockPath, Date.now().toString(), {
+        flag: "wx"
+      });
+      return true;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        // Lock was created by another process, retry
+        await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
+        continue;
+      }
+      throw err;
+    }
+  }
+  return false;
 }
 function releaseLock(teamId) {
-    const lockPath = getLockPath(teamId);
-    try {
-        if (existsSync(lockPath)) {
-            unlinkSync(lockPath);
-        }
-    }
-    catch {
-        // Ignore errors releasing lock
-    }
+  const lockPath = getLockPath(teamId);
+  try {
+    if (existsSync(lockPath)) {
+      unlinkSync(lockPath);
+    }
+  } catch {
+    // Ignore errors releasing lock
+  }
 }
+
 // ============================================================================
 // STATE OPERATIONS
 // ============================================================================
+
 export function createTeam(name, leadId) {
-    ensureTeamsDir();
-    const team = {
-        id: `team-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-        name,
-        leadId,
-        teammates: [],
-        tasks: [],
-        messages: [],
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        status: "active",
-    };
-    saveTeam(team);
-    return team;
+  ensureTeamsDir();
+  const team = {
+    id: `team-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    name,
+    leadId,
+    teammates: [],
+    tasks: [],
+    messages: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    status: "active"
+  };
+  saveTeam(team);
+  return team;
 }
 export function loadTeam(teamId) {
-    const path = getTeamPath(teamId);
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
-    }
+  const path = getTeamPath(teamId);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
 }
 export function saveTeam(team) {
-    ensureTeamsDir();
-    team.updatedAt = new Date().toISOString();
-    writeFileSync(getTeamPath(team.id), JSON.stringify(team, null, 2));
+  ensureTeamsDir();
+  team.updatedAt = new Date().toISOString();
+  writeFileSync(getTeamPath(team.id), JSON.stringify(team, null, 2));
 }
 export function listTeams() {
-    ensureTeamsDir();
-    const files = existsSync(TEAMS_DIR)
-        ? readdirSync(TEAMS_DIR).filter((f) => f.endsWith(".json") && !f.endsWith(".lock"))
-        : [];
-    return files.map((f) => {
-        try {
-            return JSON.parse(readFileSync(join(TEAMS_DIR, f), "utf-8"));
-        }
-        catch {
-            return null;
-        }
-    }).filter(Boolean);
+  ensureTeamsDir();
+  const files = existsSync(TEAMS_DIR) ? readdirSync(TEAMS_DIR).filter(f => f.endsWith(".json") && !f.endsWith(".lock")) : [];
+  return files.map(f => {
+    try {
+      return JSON.parse(readFileSync(join(TEAMS_DIR, f), "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
 }
+
 // ============================================================================
 // TEAMMATE MANAGEMENT
 // ============================================================================
+
 export async function addTeammate(teamId, teammate) {
-    if (!await acquireLock(teamId)) {
-        return null;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return null;
-        const newTeammate = {
-            ...teammate,
-            tokensUsed: { input: 0, output: 0 },
-            startedAt: new Date().toISOString(),
-        };
-        team.teammates.push(newTeammate);
-        saveTeam(team);
-        return newTeammate;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return null;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return null;
+    const newTeammate = {
+      ...teammate,
+      tokensUsed: {
+        input: 0,
+        output: 0
+      },
+      startedAt: new Date().toISOString()
+    };
+    team.teammates.push(newTeammate);
+    saveTeam(team);
+    return newTeammate;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export async function updateTeammate(teamId, teammateId, updates) {
-    if (!await acquireLock(teamId)) {
-        return false;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return false;
-        const idx = team.teammates.findIndex(t => t.id === teammateId);
-        if (idx === -1)
-            return false;
-        team.teammates[idx] = { ...team.teammates[idx], ...updates };
-        saveTeam(team);
-        return true;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return false;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return false;
+    const idx = team.teammates.findIndex(t => t.id === teammateId);
+    if (idx === -1) return false;
+    team.teammates[idx] = {
+      ...team.teammates[idx],
+      ...updates
+    };
+    saveTeam(team);
+    return true;
+  } finally {
+    releaseLock(teamId);
+  }
 }
+
 // ============================================================================
 // TASK MANAGEMENT
 // ============================================================================
+
 export async function addTask(teamId, task) {
-    if (!await acquireLock(teamId)) {
-        return null;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return null;
-        const newTask = {
-            ...task,
-            id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-            status: "pending",
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        team.tasks.push(newTask);
-        saveTeam(team);
-        return newTask;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return null;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return null;
+    const newTask = {
+      ...task,
+      id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      status: "pending",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+    team.tasks.push(newTask);
+    saveTeam(team);
+    return newTask;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export async function claimTask(teamId, taskId, teammateId) {
-    if (!await acquireLock(teamId)) {
-        return null;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return null;
-        const task = team.tasks.find(t => t.id === taskId);
-        if (!task)
-            return null;
-        // Check if task is claimable
-        if (task.status !== "pending") {
-            return null; // Already claimed or completed
-        }
-        // Check dependencies
-        if (task.dependencies?.length) {
-            const allDepsComplete = task.dependencies.every(depId => {
-                const dep = team.tasks.find(t => t.id === depId);
-                return dep?.status === "completed";
-            });
-            if (!allDepsComplete) {
-                return null; // Dependencies not met
-            }
-        }
-        // Check for file conflicts with other in-progress tasks
-        if (task.files?.length) {
-            const conflicts = team.tasks.filter(t => t.status === "in_progress" &&
-                t.id !== taskId &&
-                t.files?.some(f => task.files?.includes(f)));
-            if (conflicts.length > 0) {
-                return null; // File conflict
-            }
-        }
-        // Claim the task
-        task.status = "in_progress";
-        task.assignedTo = teammateId;
-        task.updatedAt = new Date().toISOString();
-        saveTeam(team);
-        return task;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return null;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return null;
+    const task = team.tasks.find(t => t.id === taskId);
+    if (!task) return null;
+
+    // Check if task is claimable
+    if (task.status !== "pending") {
+      return null; // Already claimed or completed
+    }
+
+    // Check dependencies
+    if (task.dependencies?.length) {
+      const allDepsComplete = task.dependencies.every(depId => {
+        const dep = team.tasks.find(t => t.id === depId);
+        return dep?.status === "completed";
+      });
+      if (!allDepsComplete) {
+        return null; // Dependencies not met
+      }
+    }
+
+    // Check for file conflicts with other in-progress tasks
+    if (task.files?.length) {
+      const conflicts = team.tasks.filter(t => t.status === "in_progress" && t.id !== taskId && t.files?.some(f => task.files?.includes(f)));
+      if (conflicts.length > 0) {
+        return null; // File conflict
+      }
+    }
+
+    // Claim the task
+    task.status = "in_progress";
+    task.assignedTo = teammateId;
+    task.updatedAt = new Date().toISOString();
+    saveTeam(team);
+    return task;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export async function completeTask(teamId, taskId, result) {
-    if (!await acquireLock(teamId)) {
-        return false;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return false;
-        const task = team.tasks.find(t => t.id === taskId);
-        if (!task)
-            return false;
-        task.status = "completed";
-        task.result = result;
-        task.updatedAt = new Date().toISOString();
-        // Check if all tasks are done
-        const allDone = team.tasks.every(t => t.status === "completed");
-        if (allDone) {
-            team.status = "completed";
-        }
-        saveTeam(team);
-        return true;
-    }
-    finally {
-        releaseLock(teamId);
+  if (!(await acquireLock(teamId))) {
+    return false;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return false;
+    const task = team.tasks.find(t => t.id === taskId);
+    if (!task) return false;
+    task.status = "completed";
+    task.result = result;
+    task.updatedAt = new Date().toISOString();
+
+    // Check if all tasks are done
+    const allDone = team.tasks.every(t => t.status === "completed");
+    if (allDone) {
+      team.status = "completed";
     }
+    saveTeam(team);
+    return true;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export async function failTask(teamId, taskId, error) {
-    if (!await acquireLock(teamId)) {
-        return false;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return false;
-        const task = team.tasks.find(t => t.id === taskId);
-        if (!task)
-            return false;
-        task.status = "blocked";
-        task.error = error;
-        task.updatedAt = new Date().toISOString();
-        saveTeam(team);
-        return true;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return false;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return false;
+    const task = team.tasks.find(t => t.id === taskId);
+    if (!task) return false;
+    task.status = "blocked";
+    task.error = error;
+    task.updatedAt = new Date().toISOString();
+    saveTeam(team);
+    return true;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export function getAvailableTasks(team) {
-    return team.tasks.filter(task => {
-        if (task.status !== "pending")
-            return false;
-        // Check dependencies
-        if (task.dependencies?.length) {
-            const allDepsComplete = task.dependencies.every(depId => {
-                const dep = team.tasks.find(t => t.id === depId);
-                return dep?.status === "completed";
-            });
-            if (!allDepsComplete)
-                return false;
-        }
-        // Check file conflicts
-        if (task.files?.length) {
-            const conflicts = team.tasks.filter(t => t.status === "in_progress" &&
-                t.files?.some(f => task.files?.includes(f)));
-            if (conflicts.length > 0)
-                return false;
-        }
-        return true;
-    });
+  return team.tasks.filter(task => {
+    if (task.status !== "pending") return false;
+
+    // Check dependencies
+    if (task.dependencies?.length) {
+      const allDepsComplete = task.dependencies.every(depId => {
+        const dep = team.tasks.find(t => t.id === depId);
+        return dep?.status === "completed";
+      });
+      if (!allDepsComplete) return false;
+    }
+
+    // Check file conflicts
+    if (task.files?.length) {
+      const conflicts = team.tasks.filter(t => t.status === "in_progress" && t.files?.some(f => task.files?.includes(f)));
+      if (conflicts.length > 0) return false;
+    }
+    return true;
+  });
 }
+
 // ============================================================================
 // MESSAGING
 // ============================================================================
+
 export async function sendMessage(teamId, from, to, content) {
-    if (!await acquireLock(teamId)) {
-        return null;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return null;
-        const message = {
-            id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-            from,
-            to,
-            content,
-            timestamp: new Date().toISOString(),
-            read: false,
-        };
-        team.messages.push(message);
-        saveTeam(team);
-        return message;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return null;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return null;
+    const message = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      from,
+      to,
+      content,
+      timestamp: new Date().toISOString(),
+      read: false
+    };
+    team.messages.push(message);
+    saveTeam(team);
+    return message;
+  } finally {
+    releaseLock(teamId);
+  }
 }
 export async function getUnreadMessages(teamId, recipientId) {
-    const team = loadTeam(teamId);
-    if (!team)
-        return [];
-    return team.messages.filter(m => !m.read &&
-        (m.to === recipientId || m.to === "all"));
+  const team = loadTeam(teamId);
+  if (!team) return [];
+  return team.messages.filter(m => !m.read && (m.to === recipientId || m.to === "all"));
 }
 export async function markMessagesRead(teamId, messageIds) {
-    if (!await acquireLock(teamId)) {
-        return false;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return false;
-        for (const msg of team.messages) {
-            if (messageIds.includes(msg.id)) {
-                msg.read = true;
-            }
-        }
-        saveTeam(team);
-        return true;
-    }
-    finally {
-        releaseLock(teamId);
+  if (!(await acquireLock(teamId))) {
+    return false;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return false;
+    for (const msg of team.messages) {
+      if (messageIds.includes(msg.id)) {
+        msg.read = true;
+      }
     }
+    saveTeam(team);
+    return true;
+  } finally {
+    releaseLock(teamId);
+  }
 }
+
 // ============================================================================
 // TEAM STATUS
 // ============================================================================
+
 export function getTeamProgress(team) {
-    const total = team.tasks.length;
-    const completed = team.tasks.filter(t => t.status === "completed").length;
-    const inProgress = team.tasks.filter(t => t.status === "in_progress").length;
-    const pending = team.tasks.filter(t => t.status === "pending").length;
-    const blocked = team.tasks.filter(t => t.status === "blocked").length;
-    return {
-        total,
-        completed,
-        inProgress,
-        pending,
-        blocked,
-        percentComplete: total > 0 ? Math.round((completed / total) * 100) : 0,
-    };
+  const total = team.tasks.length;
+  const completed = team.tasks.filter(t => t.status === "completed").length;
+  const inProgress = team.tasks.filter(t => t.status === "in_progress").length;
+  const pending = team.tasks.filter(t => t.status === "pending").length;
+  const blocked = team.tasks.filter(t => t.status === "blocked").length;
+  return {
+    total,
+    completed,
+    inProgress,
+    pending,
+    blocked,
+    percentComplete: total > 0 ? Math.round(completed / total * 100) : 0
+  };
 }
 export async function setTeamStatus(teamId, status) {
-    if (!await acquireLock(teamId)) {
-        return false;
-    }
-    try {
-        const team = loadTeam(teamId);
-        if (!team)
-            return false;
-        team.status = status;
-        saveTeam(team);
-        return true;
-    }
-    finally {
-        releaseLock(teamId);
-    }
+  if (!(await acquireLock(teamId))) {
+    return false;
+  }
+  try {
+    const team = loadTeam(teamId);
+    if (!team) return false;
+    team.status = status;
+    saveTeam(team);
+    return true;
+  } finally {
+    releaseLock(teamId);
+  }
 }
+//# sourceMappingURL=team-state.js.map