@lwmxiaobei/xbcode 1.0.0

package/dist/task-manager.js

@@ -0,0 +1,280 @@
+import fs from "node:fs";
+import path from "node:path";
+import lockfile from "proper-lockfile";
+const STATUS_SYMBOLS = {
+    pending: "[ ]",
+    assigned: "[=]",
+    in_progress: "[>]",
+    blocked: "[! ]",
+    completed: "[x]",
+    failed: "[-]",
+};
+const LOCK_OPTIONS = {
+    retries: {
+        retries: 100,
+        minTimeout: 5,
+        maxTimeout: 200,
+    },
+};
+function createThreadId(taskId) {
+    return `task_${taskId}`;
+}
+export class TaskManager {
+    dir;
+    lockFilePath;
+    constructor(tasksDir) {
+        this.dir = tasksDir;
+        fs.mkdirSync(this.dir, { recursive: true });
+        this.lockFilePath = path.join(this.dir, "tasks.lock");
+        if (!fs.existsSync(this.lockFilePath)) {
+            fs.writeFileSync(this.lockFilePath, "", "utf8");
+        }
+    }
+    async withLock(fn) {
+        const release = await lockfile.lock(this.lockFilePath, LOCK_OPTIONS);
+        try {
+            return await fn();
+        }
+        finally {
+            await release();
+        }
+    }
+    nextId() {
+        const files = fs.readdirSync(this.dir).filter((f) => /^task_\d+\.json$/.test(f));
+        if (files.length === 0)
+            return 1;
+        const ids = files.map((f) => Number(f.match(/task_(\d+)\.json/)?.[1] ?? 0));
+        return Math.max(...ids) + 1;
+    }
+    taskPath(id) {
+        return path.join(this.dir, `task_${id}.json`);
+    }
+    normalizeTask(task) {
+        const now = new Date().toISOString();
+        return {
+            id: task.id,
+            subject: task.subject,
+            description: task.description ?? "",
+            status: task.status ?? "pending",
+            owner: task.owner ?? "lead",
+            assignee: task.assignee,
+            threadId: task.threadId ?? createThreadId(task.id),
+            resultSummary: task.resultSummary,
+            blockedReason: task.blockedReason,
+            createdAt: task.createdAt ?? now,
+            updatedAt: task.updatedAt ?? task.createdAt ?? now,
+            blockedBy: Array.isArray(task.blockedBy) ? task.blockedBy : [],
+            blocks: Array.isArray(task.blocks) ? task.blocks : [],
+        };
+    }
+    load(id) {
+        const content = fs.readFileSync(this.taskPath(id), "utf8");
+        return this.normalizeTask(JSON.parse(content));
+    }
+    save(task) {
+        const normalized = this.normalizeTask(task);
+        fs.writeFileSync(this.taskPath(normalized.id), JSON.stringify(normalized, null, 2), "utf8");
+    }
+    allTasks() {
+        const files = fs.readdirSync(this.dir).filter((f) => /^task_\d+\.json$/.test(f));
+        return files.map((f) => {
+            const id = Number(f.match(/task_(\d+)\.json/)?.[1] ?? 0);
+            return this.load(id);
+        });
+    }
+    getTaskInternal(taskId) {
+        try {
+            return this.load(taskId);
+        }
+        catch {
+            return null;
+        }
+    }
+    async create(subject, description, owner = "lead", assignee) {
+        return this.withLock(() => {
+            const id = this.nextId();
+            const now = new Date().toISOString();
+            const task = {
+                id,
+                subject,
+                description: description ?? "",
+                status: assignee ? "assigned" : "pending",
+                owner,
+                assignee,
+                threadId: createThreadId(id),
+                createdAt: now,
+                updatedAt: now,
+                blockedBy: [],
+                blocks: [],
+            };
+            this.save(task);
+            return JSON.stringify(task, null, 2);
+        });
+    }
+    async update(taskId, status, addBlockedBy, addBlocks, assignee, resultSummary, blockedReason) {
+        return this.withLock(() => {
+            let task;
+            try {
+                task = this.load(taskId);
+            }
+            catch {
+                return `Error: Task ${taskId} not found.`;
+            }
+            if (addBlockedBy) {
+                for (const depId of addBlockedBy) {
+                    if (!task.blockedBy.includes(depId))
+                        task.blockedBy.push(depId);
+                    try {
+                        const dep = this.load(depId);
+                        if (!dep.blocks.includes(taskId)) {
+                            dep.blocks.push(taskId);
+                            dep.updatedAt = new Date().toISOString();
+                            this.save(dep);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (addBlocks) {
+                for (const depId of addBlocks) {
+                    if (!task.blocks.includes(depId))
+                        task.blocks.push(depId);
+                    try {
+                        const dep = this.load(depId);
+                        if (!dep.blockedBy.includes(taskId)) {
+                            dep.blockedBy.push(taskId);
+                            dep.updatedAt = new Date().toISOString();
+                            this.save(dep);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (typeof assignee === "string" && assignee.trim()) {
+                task.assignee = assignee.trim();
+                if (task.status === "pending") {
+                    task.status = "assigned";
+                }
+            }
+            if (typeof resultSummary === "string") {
+                task.resultSummary = resultSummary;
+            }
+            if (typeof blockedReason === "string") {
+                task.blockedReason = blockedReason;
+            }
+            if (status) {
+                task.status = status;
+                if (status !== "blocked") {
+                    task.blockedReason = blockedReason ?? task.blockedReason;
+                }
+            }
+            task.updatedAt = new Date().toISOString();
+            this.save(task);
+            if (task.status === "completed") {
+                this.clearDependency(task.id);
+            }
+            return JSON.stringify(task, null, 2);
+        });
+    }
+    clearDependency(completedId) {
+        const all = this.allTasks();
+        for (const t of all) {
+            const idx = t.blockedBy.indexOf(completedId);
+            if (idx !== -1) {
+                t.blockedBy.splice(idx, 1);
+                t.updatedAt = new Date().toISOString();
+                this.save(t);
+            }
+        }
+    }
+    async list() {
+        return this.withLock(() => {
+            const tasks = this.allTasks();
+            if (tasks.length === 0)
+                return "(no tasks)";
+            return tasks
+                .map((t) => {
+                let line = `${STATUS_SYMBOLS[t.status]} #${t.id}: ${t.subject}`;
+                if (t.assignee)
+                    line += ` assignee=${t.assignee}`;
+                if (t.blockedBy.length > 0)
+                    line += ` (blocked by: ${t.blockedBy.join(", ")})`;
+                if (t.blockedReason)
+                    line += ` reason=${t.blockedReason}`;
+                return line;
+            })
+                .join("\n");
+        });
+    }
+    async getTask(taskId) {
+        return this.withLock(() => {
+            return this.getTaskInternal(taskId);
+        });
+    }
+    async listTasks() {
+        return this.withLock(() => {
+            return this.allTasks().sort((left, right) => left.id - right.id);
+        });
+    }
+    async listAssignedTo(name) {
+        return this.withLock(() => {
+            const normalized = name.trim();
+            return this.allTasks()
+                .filter((task) => task.assignee === normalized && ["assigned", "in_progress", "blocked"].includes(task.status))
+                .sort((left, right) => left.id - right.id);
+        });
+    }
+    async claimNext(assignee) {
+        return this.withLock(() => {
+            const nextTask = this.allTasks()
+                .filter((task) => task.assignee === assignee && task.status === "assigned")
+                .sort((left, right) => left.id - right.id)[0];
+            if (!nextTask) {
+                return null;
+            }
+            nextTask.status = "in_progress";
+            nextTask.updatedAt = new Date().toISOString();
+            this.save(nextTask);
+            return nextTask;
+        });
+    }
+    async formatTask(taskId) {
+        return this.withLock(() => {
+            const task = this.getTaskInternal(taskId);
+            if (!task) {
+                return `Error: Task ${taskId} not found.`;
+            }
+            const lines = [
+                `#${task.id} ${task.subject}`,
+                `status=${task.status}`,
+                `owner=${task.owner}`,
+                `assignee=${task.assignee ?? "-"}`,
+                `thread=${task.threadId}`,
+                `created_at=${task.createdAt}`,
+                `updated_at=${task.updatedAt}`,
+            ];
+            if (task.description)
+                lines.push("", task.description);
+            if (task.resultSummary)
+                lines.push("", `result: ${task.resultSummary}`);
+            if (task.blockedReason)
+                lines.push("", `blocked: ${task.blockedReason}`);
+            if (task.blockedBy.length > 0)
+                lines.push(`blocked_by=${task.blockedBy.join(", ")}`);
+            if (task.blocks.length > 0)
+                lines.push(`blocks=${task.blocks.join(", ")}`);
+            return lines.join("\n");
+        });
+    }
+    async get(taskId) {
+        return this.withLock(() => {
+            const task = this.getTaskInternal(taskId);
+            return task ? JSON.stringify(task, null, 2) : `Error: Task ${taskId} not found.`;
+        });
+    }
+    async hasActiveTasks() {
+        return this.withLock(() => {
+            return this.allTasks().some((t) => ["pending", "assigned", "in_progress", "blocked"].includes(t.status));
+        });
+    }
+}

package/dist/team-types.js

@@ -0,0 +1 @@
+export {};

package/dist/teammate-manager.js

@@ -0,0 +1,266 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createSessionId } from "./session-store.js";
+function sortMembers(members) {
+    return [...members].sort((left, right) => left.name.localeCompare(right.name));
+}
+export class TeammateManager {
+    teamDir;
+    messageBus;
+    leadName;
+    configPath;
+    runtimeControls = new Map();
+    constructor(teamDir, messageBus, leadName = "lead") {
+        this.teamDir = teamDir;
+        this.messageBus = messageBus;
+        this.leadName = leadName;
+        fs.mkdirSync(this.teamDir, { recursive: true });
+        this.configPath = path.join(this.teamDir, "config.json");
+        this.ensureConfig();
+        this.messageBus.ensureInbox(this.leadName);
+        this.resetEphemeralStatuses();
+    }
+    getLeadName() {
+        return this.leadName;
+    }
+    defaultConfig() {
+        return {
+            version: 2,
+            leadName: this.leadName,
+            members: [],
+        };
+    }
+    ensureConfig() {
+        if (fs.existsSync(this.configPath)) {
+            return;
+        }
+        fs.writeFileSync(this.configPath, `${JSON.stringify(this.defaultConfig(), null, 2)}\n`, "utf8");
+    }
+    loadConfig() {
+        this.ensureConfig();
+        try {
+            const content = fs.readFileSync(this.configPath, "utf8");
+            const parsed = JSON.parse(content);
+            return {
+                version: 2,
+                leadName: this.leadName,
+                members: Array.isArray(parsed.members) ? sortMembers(parsed.members) : [],
+            };
+        }
+        catch {
+            return this.defaultConfig();
+        }
+    }
+    saveConfig(config) {
+        const normalized = {
+            version: 2,
+            leadName: this.leadName,
+            members: sortMembers(config.members),
+        };
+        fs.writeFileSync(this.configPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    }
+    resetEphemeralStatuses() {
+        const config = this.loadConfig();
+        let changed = false;
+        for (const member of config.members) {
+            if (member.status !== "stopped") {
+                member.status = "stopped";
+                member.currentTaskId = undefined;
+                member.currentThreadId = undefined;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.saveConfig(config);
+        }
+    }
+    createRuntimeState(name, role) {
+        return {
+            name,
+            role,
+            sessionId: createSessionId(),
+            responseHistory: [],
+            chatHistory: [],
+            turnCount: 0,
+            launchedAt: Date.now(),
+            roundsSinceTask: 0,
+            compactCount: 0,
+        };
+    }
+    listMembers() {
+        return this.loadConfig().members;
+    }
+    getMember(name) {
+        return this.listMembers().find((member) => member.name === name);
+    }
+    ensureMember(name, role) {
+        const now = new Date().toISOString();
+        const config = this.loadConfig();
+        const existing = config.members.find((member) => member.name === name);
+        if (existing) {
+            existing.role = role;
+            existing.lastActiveAt = now;
+            existing.lastError = undefined;
+            if (existing.status === "error" || existing.status === "stopped") {
+                existing.status = "idle";
+            }
+            this.saveConfig(config);
+            this.messageBus.ensureInbox(name);
+            return existing;
+        }
+        const member = {
+            name,
+            role,
+            status: "idle",
+            createdAt: now,
+            lastActiveAt: now,
+        };
+        config.members.push(member);
+        this.saveConfig(config);
+        this.messageBus.ensureInbox(name);
+        return member;
+    }
+    setStatus(name, status, lastError) {
+        const config = this.loadConfig();
+        const member = config.members.find((entry) => entry.name === name);
+        if (!member) {
+            return;
+        }
+        member.status = status;
+        member.lastActiveAt = new Date().toISOString();
+        if (lastError) {
+            member.lastError = lastError;
+        }
+        else if (status !== "error") {
+            member.lastError = undefined;
+        }
+        if (status === "idle" || status === "stopped") {
+            member.currentTaskId = undefined;
+            member.currentThreadId = undefined;
+        }
+        this.saveConfig(config);
+    }
+    setCurrentWork(name, taskId, threadId, summary) {
+        const config = this.loadConfig();
+        const member = config.members.find((entry) => entry.name === name);
+        if (!member) {
+            return;
+        }
+        member.lastActiveAt = new Date().toISOString();
+        member.currentTaskId = taskId;
+        member.currentThreadId = threadId;
+        if (typeof summary === "string") {
+            member.lastSummary = summary;
+        }
+        this.saveConfig(config);
+    }
+    markWorking(name) {
+        this.setStatus(name, "working");
+    }
+    markBlocked(name, summary) {
+        this.setStatus(name, "blocked");
+        if (summary) {
+            this.setCurrentWork(name, this.getMember(name)?.currentTaskId, this.getMember(name)?.currentThreadId, summary);
+        }
+    }
+    markIdle(name) {
+        this.setStatus(name, "idle");
+    }
+    markStopped(name) {
+        this.setStatus(name, "stopped");
+    }
+    markError(name, message) {
+        this.setStatus(name, "error", message);
+    }
+    isRunning(name) {
+        return Boolean(this.runtimeControls.get(name)?.running);
+    }
+    startRuntime(name, role, runner) {
+        const current = this.runtimeControls.get(name);
+        if (current?.running) {
+            return { started: false, control: current };
+        }
+        const control = {
+            name,
+            role,
+            stopRequested: false,
+            waiters: new Set(),
+            running: undefined,
+            state: this.createRuntimeState(name, role),
+        };
+        this.runtimeControls.set(name, control);
+        control.running = Promise.resolve()
+            .then(() => runner(control))
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.markError(name, message);
+            // P1：删除 task_failed 协议字段（eventType/taskId/threadId），仅给 lead 邮箱
+            // 写入人类可读的失败通知。任务级失败状态依然通过 task manager 体现。
+            // void：runner 失败本身已由 markError 记录，这里 send 失败也只是丢条通知，不阻断。
+            void this.messageBus.send({
+                from: name,
+                to: this.leadName,
+                content: `Teammate ${name} failed: ${message}`,
+            });
+        })
+            .finally(() => {
+            control.running = undefined;
+            control.waiters.clear();
+            const currentMember = this.getMember(name);
+            if (currentMember && currentMember.status !== "error") {
+                this.markStopped(name);
+            }
+        });
+        return { started: true, control };
+    }
+    wake(name) {
+        const control = this.runtimeControls.get(name);
+        if (!control) {
+            return;
+        }
+        const waiters = [...control.waiters];
+        control.waiters.clear();
+        for (const waiter of waiters) {
+            waiter();
+        }
+    }
+    async waitForWake(control) {
+        // 进入等待前先看一眼未读数：若有未读消息则不应该睡，立刻返回让上层 drain。
+        if (control.stopRequested || (await this.messageBus.unreadCount(control.name)) > 0) {
+            return;
+        }
+        await new Promise((resolve) => {
+            control.waiters.add(resolve);
+        });
+    }
+    requestStop(name) {
+        const control = this.runtimeControls.get(name);
+        if (!control) {
+            this.markStopped(name);
+            return false;
+        }
+        control.stopRequested = true;
+        this.wake(name);
+        return true;
+    }
+    shouldStop(control) {
+        return control.stopRequested;
+    }
+    // P1：异步化。inboxSize 同步 API 已废弃，改为 await unreadCount。
+    // 用 Promise.all 并发查询所有成员未读数，避免 N 次串行 fs 读放大延迟。
+    async formatTeamStatus() {
+        const members = this.listMembers();
+        if (members.length === 0) {
+            return `team_dir ${this.teamDir}\n(no teammates)`;
+        }
+        const lines = await Promise.all(members.map(async (member) => {
+            const inboxSize = await this.messageBus.unreadCount(member.name);
+            const errorSuffix = member.lastError ? ` error=${member.lastError}` : "";
+            const workSuffix = member.currentTaskId ? ` task=${member.currentTaskId}` : "";
+            const threadSuffix = member.currentThreadId ? ` thread=${member.currentThreadId}` : "";
+            const summarySuffix = member.lastSummary ? ` summary=${member.lastSummary}` : "";
+            return `- ${member.name} [${member.status}] role=${member.role} inbox=${inboxSize} last_active=${member.lastActiveAt}${workSuffix}${threadSuffix}${summarySuffix}${errorSuffix}`;
+        }));
+        return [`team_dir ${this.teamDir}`, ...lines].join("\n");
+    }
+}