vibe-coding-master 0.8.2 → 0.8.4

package/dist/backend/services/role-stall-detector-service.js

@@ -1,322 +0,0 @@
-import { isVcmRoleName } from "../../shared/constants.js";
-import { VcmError } from "../errors.js";
-export const ROLE_MODEL_STALL_TIMEOUT_MS = 10 * 60 * 1000;
-export const ROLE_TOOL_STALL_TIMEOUT_MS = 10 * 60 * 1000;
-export const ROLE_SUBAGENT_STALL_TIMEOUT_MS = 30 * 60 * 1000;
-const TOOL_TIMEOUT_GRACE_MS = 30_000;
-export function createRoleStallDetectorService(deps) {
-    const modelTimeoutMs = deps.modelTimeoutMs ?? ROLE_MODEL_STALL_TIMEOUT_MS;
-    const toolTimeoutMs = deps.toolTimeoutMs ?? ROLE_TOOL_STALL_TIMEOUT_MS;
-    const subagentTimeoutMs = deps.subagentTimeoutMs ?? ROLE_SUBAGENT_STALL_TIMEOUT_MS;
-    const now = deps.now ?? (() => new Date().toISOString());
-    const setTimer = deps.setTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
-    const clearTimer = deps.clearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
-    const monitors = new Map();
-    return {
-        async recordHook(input) {
-            if (!isVcmRoleName(input.role)) {
-                return;
-            }
-            const key = monitorKey(input.repoRoot, input.taskSlug);
-            if (input.eventName === "Stop" || input.eventName === "StopFailure") {
-                clearMonitor(key);
-                return;
-            }
-            const [session, round] = await Promise.all([
-                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role),
-                deps.roundService.getSessionRoundState(roundInput(input))
-            ]);
-            if (!session
-                || session.status !== "running"
-                || session.activityStatus !== "running"
-                || round.status !== "running"
-                || round.activeRole !== input.role
-                || !round.roundId) {
-                clearMonitor(key);
-                return;
-            }
-            let monitor = monitors.get(key);
-            if (!monitor
-                || monitor.sessionId !== session.id
-                || monitor.runtimeSessionToken !== session.runtimeSessionToken
-                || monitor.roundId !== round.roundId
-                || monitor.role !== input.role) {
-                clearMonitor(key);
-                monitor = {
-                    context: taskInput(input),
-                    role: input.role,
-                    sessionId: session.id,
-                    runtimeSessionToken: session.runtimeSessionToken,
-                    roundId: round.roundId,
-                    phase: "awaiting-model",
-                    phaseStartedAt: now(),
-                    generation: 0,
-                    activeTools: new Map()
-                };
-                monitors.set(key, monitor);
-            }
-            advanceMonitor(key, monitor, input.eventName, input.event);
-        },
-        async reconcileTask(input) {
-            const key = monitorKey(input.repoRoot, input.taskSlug);
-            for (const [candidateKey, monitor] of monitors) {
-                if (monitor.context.repoRoot === input.repoRoot && candidateKey !== key) {
-                    clearMonitor(candidateKey);
-                }
-            }
-            const monitor = monitors.get(key);
-            if (!monitor) {
-                return;
-            }
-            const [session, round] = await Promise.all([
-                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, monitor.role),
-                deps.roundService.getSessionRoundState(roundInput(input))
-            ]);
-            if (!session
-                || session.id !== monitor.sessionId
-                || session.runtimeSessionToken !== monitor.runtimeSessionToken
-                || session.status !== "running"
-                || session.activityStatus !== "running"
-                || round.status !== "running"
-                || round.activeRole !== monitor.role
-                || round.roundId !== monitor.roundId) {
-                clearMonitor(key);
-            }
-        },
-        getWarning(repoRoot, taskSlug) {
-            const warning = monitors.get(monitorKey(repoRoot, taskSlug))?.warning;
-            return warning ? { ...warning } : null;
-        },
-        ignoreWarning(repoRoot, taskSlug, warningId) {
-            const monitor = requireWarning(repoRoot, taskSlug, warningId);
-            monitor.ignoredGeneration = monitor.generation;
-            monitor.warning = undefined;
-            cancelTimer(monitor);
-            return { ok: true, warning: null };
-        },
-        async recoverWarning(input) {
-            const key = monitorKey(input.repoRoot, input.taskSlug);
-            const monitor = requireWarning(input.repoRoot, input.taskSlug, input.warningId);
-            const [session, round] = await Promise.all([
-                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, monitor.role),
-                deps.roundService.getSessionRoundState(roundInput(input))
-            ]);
-            if (!session
-                || session.id !== monitor.sessionId
-                || session.runtimeSessionToken !== monitor.runtimeSessionToken
-                || session.status !== "running"
-                || session.activityStatus !== "running"
-                || round.status !== "running"
-                || round.activeRole !== monitor.role
-                || round.roundId !== monitor.roundId) {
-                clearMonitor(key);
-                return { ok: true, warning: null };
-            }
-            await deps.sessionService.recoverRoleSession(input.repoRoot, input.taskSlug, {
-                role: monitor.role,
-                expectedSessionId: monitor.sessionId,
-                expectedRuntimeSessionToken: monitor.runtimeSessionToken,
-                recoveryPrompt: renderRecoveryPrompt(monitor)
-            });
-            clearMonitor(key);
-            return { ok: true, warning: null };
-        },
-        clearProject(repoRoot) {
-            for (const [key, monitor] of monitors) {
-                if (monitor.context.repoRoot === repoRoot) {
-                    clearMonitor(key);
-                }
-            }
-        },
-        stop() {
-            for (const key of [...monitors.keys()]) {
-                clearMonitor(key);
-            }
-        }
-    };
-    function advanceMonitor(key, monitor, eventName, event) {
-        monitor.generation += 1;
-        monitor.warning = undefined;
-        monitor.ignoredGeneration = undefined;
-        cancelTimer(monitor);
-        switch (eventName) {
-            case "UserPromptSubmit":
-            case "PostCompact":
-            case "PostToolBatch":
-                monitor.activeTools.clear();
-                monitor.currentTool = undefined;
-                setPhase(key, monitor, "awaiting-model", modelTimeoutMs);
-                return;
-            case "PreToolUse": {
-                const tool = readTool(event, toolTimeoutMs, subagentTimeoutMs);
-                const toolKey = tool.toolUseId ?? `anonymous-${monitor.generation}`;
-                monitor.activeTools.set(toolKey, tool);
-                monitor.currentTool = tool;
-                setPhase(key, monitor, tool.toolName === "Agent" ? "subagent-running" : "tool-running", tool.timeoutMs);
-                return;
-            }
-            case "SubagentStart":
-                setPhase(key, monitor, "subagent-running", subagentTimeoutMs);
-                return;
-            case "PostToolUse":
-            case "PostToolUseFailure": {
-                const toolUseId = stringValue(event.tool_use_id);
-                if (toolUseId) {
-                    monitor.activeTools.delete(toolUseId);
-                }
-                monitor.currentTool = firstTool(monitor.activeTools);
-                if (monitor.currentTool) {
-                    setPhase(key, monitor, monitor.currentTool.toolName === "Agent" ? "subagent-running" : "tool-running", monitor.currentTool.timeoutMs);
-                }
-                return;
-            }
-            case "SubagentStop":
-                monitor.currentTool = firstTool(monitor.activeTools);
-                if (monitor.currentTool) {
-                    setPhase(key, monitor, monitor.currentTool.toolName === "Agent" ? "subagent-running" : "tool-running", monitor.currentTool.timeoutMs);
-                }
-                return;
-            case "PreCompact":
-                monitor.activeTools.clear();
-                monitor.currentTool = undefined;
-                setPhase(key, monitor, "compacting", modelTimeoutMs);
-                return;
-            case "PermissionRequest":
-                setPhase(key, monitor, "awaiting-permission");
-                return;
-            default:
-                return;
-        }
-    }
-    function setPhase(key, monitor, phase, timeoutMs) {
-        monitor.phase = phase;
-        monitor.phaseStartedAt = now();
-        if (timeoutMs === undefined) {
-            return;
-        }
-        const generation = monitor.generation;
-        monitor.timer = setTimer(() => {
-            void detectStall(key, generation).catch(() => undefined);
-        }, timeoutMs);
-    }
-    async function detectStall(key, generation) {
-        const monitor = monitors.get(key);
-        if (!monitor || monitor.generation !== generation || monitor.ignoredGeneration === generation) {
-            return;
-        }
-        const [session, round] = await Promise.all([
-            deps.sessionService.getRoleSession(monitor.context.repoRoot, monitor.context.taskSlug, monitor.role),
-            deps.roundService.getSessionRoundState(roundInput(monitor.context))
-        ]);
-        if (!session
-            || session.id !== monitor.sessionId
-            || session.runtimeSessionToken !== monitor.runtimeSessionToken
-            || session.status !== "running"
-            || session.activityStatus !== "running"
-            || round.status !== "running"
-            || round.activeRole !== monitor.role
-            || round.roundId !== monitor.roundId) {
-            clearMonitor(key);
-            return;
-        }
-        const detectedAt = now();
-        monitor.timer = undefined;
-        monitor.warning = {
-            id: `${monitor.sessionId}:${monitor.roundId}:${generation}:${detectedAt}`,
-            taskSlug: monitor.context.taskSlug,
-            role: monitor.role,
-            sessionId: monitor.sessionId,
-            runtimeSessionToken: monitor.runtimeSessionToken,
-            roundId: monitor.roundId,
-            phase: monitor.phase,
-            phaseStartedAt: monitor.phaseStartedAt,
-            detectedAt,
-            toolUseId: monitor.currentTool?.toolUseId,
-            toolName: monitor.currentTool?.toolName
-        };
-    }
-    function requireWarning(repoRoot, taskSlug, warningId) {
-        const monitor = monitors.get(monitorKey(repoRoot, taskSlug));
-        if (!monitor?.warning || monitor.warning.id !== warningId) {
-            throw new VcmError({
-                code: "ROLE_STALL_WARNING_STALE",
-                message: "The role stall warning is no longer active.",
-                statusCode: 409,
-                hint: "Refresh the task workspace before retrying the action."
-            });
-        }
-        return monitor;
-    }
-    function cancelTimer(monitor) {
-        if (monitor.timer === undefined) {
-            return;
-        }
-        clearTimer(monitor.timer);
-        monitor.timer = undefined;
-    }
-    function clearMonitor(key) {
-        const monitor = monitors.get(key);
-        if (!monitor) {
-            return;
-        }
-        cancelTimer(monitor);
-        monitors.delete(key);
-    }
-}
-function monitorKey(repoRoot, taskSlug) {
-    return `${repoRoot}:${taskSlug}`;
-}
-function taskInput(input) {
-    return {
-        repoRoot: input.repoRoot,
-        taskRepoRoot: input.taskRepoRoot,
-        stateRoot: input.stateRoot,
-        taskSlug: input.taskSlug
-    };
-}
-function roundInput(input) {
-    return {
-        repoRoot: input.repoRoot,
-        stateRepoRoot: input.taskRepoRoot,
-        stateRoot: input.stateRoot,
-        taskSlug: input.taskSlug
-    };
-}
-function readTool(event, defaultTimeoutMs, subagentTimeoutMs) {
-    const toolName = stringValue(event.tool_name);
-    const toolUseId = stringValue(event.tool_use_id);
-    const input = objectValue(event.tool_input);
-    const requestedTimeout = numberValue(input?.timeout);
-    return {
-        toolName,
-        toolUseId,
-        timeoutMs: toolName === "Agent"
-            ? subagentTimeoutMs
-            : Math.max(defaultTimeoutMs, requestedTimeout ? requestedTimeout + TOOL_TIMEOUT_GRACE_MS : 0)
-    };
-}
-function firstTool(tools) {
-    return tools.values().next().value;
-}
-function renderRecoveryPrompt(monitor) {
-    const phase = monitor.currentTool?.toolName
-        ? `${monitor.phase} (${monitor.currentTool.toolName})`
-        : monitor.phase;
-    return [
-        "[VCM Session Recovery]",
-        `The previous ${monitor.role} turn may have stalled during ${phase}.`,
-        "Continue the current assigned work from the existing Claude session context.",
-        "Do not repeat completed work unless it is needed to verify the current state."
-    ].join("\n");
-}
-function objectValue(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function stringValue(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}

package/dist/shared/types/role-stall.js

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