whale-code 6.4.0

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

@@ -0,0 +1,398 @@
+/**
+ * Team State — Shared state management for Agent Teams
+ *
+ * Following Anthropic's official patterns:
+ * - Shared task list with status tracking
+ * - File-based locking to prevent conflicts
+ * - Inter-agent message queue
+ * - Dependencies between tasks
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ============================================================================
+// STORAGE
+// ============================================================================
+const TEAMS_DIR = join(homedir(), ".swagmanager", "teams");
+function ensureTeamsDir() {
+    if (!existsSync(TEAMS_DIR)) {
+        mkdirSync(TEAMS_DIR, { recursive: true });
+    }
+}
+function getTeamPath(teamId) {
+    return join(TEAMS_DIR, `${teamId}.json`);
+}
+function getLockPath(teamId) {
+    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;
+        }
+    }
+    return false;
+}
+function releaseLock(teamId) {
+    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;
+}
+export function loadTeam(teamId) {
+    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));
+}
+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);
+}
+// ============================================================================
+// 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);
+    }
+}
+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);
+    }
+}
+// ============================================================================
+// 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);
+    }
+}
+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);
+    }
+}
+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);
+    }
+}
+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);
+    }
+}
+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;
+    });
+}
+// ============================================================================
+// 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);
+    }
+}
+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"));
+}
+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);
+    }
+}
+// ============================================================================
+// 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,
+    };
+}
+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);
+    }
+}

package/dist/cli/services/teammate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Teammate — Independent agent instance in a Team
+ *
+ * Following Anthropic's official patterns:
+ * - Runs in separate context window (worker thread)
+ * - Works on tasks from shared task list
+ * - Can message other teammates directly
+ * - Full tool access (not restricted like subagents)
+ */
+import { Worker } from "worker_threads";
+export interface TeammateWorkerData {
+    teamId: string;
+    teammateId: string;
+    teammateName: string;
+    model: string;
+    cwd: string;
+    parentConversationId: string;
+    teamName: string;
+    authToken?: string;
+}
+export interface TeammateMessage {
+    type: "progress" | "task_started" | "task_completed" | "message_sent" | "done" | "error";
+    teammateId: string;
+    taskId?: string;
+    content: string;
+    tokensUsed?: {
+        input: number;
+        output: number;
+    };
+}
+export declare function spawnTeammate(teamId: string, teammateId: string, teammateName: string, model: string, cwd: string, parentConversationId: string, teamName: string): Promise<Worker>;