vibe-coding-master 0.6.1 → 0.6.3

package/dist/backend/services/translation-service.js

@@ -13,6 +13,8 @@ const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
 const TRANSLATION_TASK_FEED_RETENTION_LIMIT = 2000;
+const GATEWAY_TRANSLATION_REUSE_GRACE_MS = 1500;
+const GATEWAY_TRANSLATION_REUSE_POLL_MS = 50;
 export function createTranslationService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
@@ -241,11 +243,13 @@ export function createTranslationService(deps) {
         let displayed = false;
         if (event.kind === "text") {
             const shouldTranslate = shouldTranslateTextTranscriptEvent(state, event, config);
+            const metadata = getTextTranscriptEntryMetadata(event);
             displayed = shouldTranslate
                 ? processClaudeOutputText(sessionId, event.text, config, event.id, {
-                    flushImmediately: event.stopReason === "end_turn"
+                    flushImmediately: event.stopReason === "end_turn",
+                    metadata
                 })
-                : pushPreservedProseEntry(sessionId, event.id, event.text, config);
+                : pushPreservedProseEntry(sessionId, event.id, event.text, config, metadata);
             if (displayed && shouldTranslate) {
                 state.lastAssistantText = event.text;
             }
@@ -267,6 +271,9 @@ export function createTranslationService(deps) {
         if (config.outputMode === "all") {
             return true;
         }
+        if (config.outputMode === "round-final") {
+            return false;
+        }
         if (event.stopReason !== "end_turn") {
             return false;
         }
@@ -279,9 +286,16 @@ export function createTranslationService(deps) {
         return startClaudeOutputTranslation(sessionId, rawText, config, {
             entryId,
             replaceExisting: false,
-            flushImmediately: options.flushImmediately === true
+            flushImmediately: options.flushImmediately === true,
+            metadata: options.metadata
         }) !== undefined;
     }
+    function getTextTranscriptEntryMetadata(event) {
+        return {
+            ...(event.stopReason !== undefined ? { transcriptStopReason: event.stopReason } : {}),
+            transcriptTimestamp: event.timestamp
+        };
+    }
     function startClaudeOutputTranslation(sessionId, rawText, config, options) {
         const session = deps.runtime.getSession(sessionId);
         const roleSession = deps.sessionRegistry.get(sessionId);
@@ -302,7 +316,8 @@ export function createTranslationService(deps) {
                 config,
                 status: "queued",
                 contextUsed: false,
-                id: options.entryId
+                id: options.entryId,
+                ...options.metadata
             })
         };
         if (options.replaceExisting) {
@@ -437,10 +452,10 @@ export function createTranslationService(deps) {
     function pushPreservedTranscriptEntry(sessionId, entryId, sourceText, config) {
         return pushPreservedOutputEntry(sessionId, entryId, sourceText, "tool-output", config);
     }
-    function pushPreservedProseEntry(sessionId, entryId, sourceText, config) {
-        return pushPreservedOutputEntry(sessionId, entryId, sourceText, "prose", config);
+    function pushPreservedProseEntry(sessionId, entryId, sourceText, config, metadata = {}) {
+        return pushPreservedOutputEntry(sessionId, entryId, sourceText, "prose", config, metadata);
     }
-    function pushPreservedOutputEntry(sessionId, entryId, sourceText, sourceKind, config) {
+    function pushPreservedOutputEntry(sessionId, entryId, sourceText, sourceKind, config, metadata = {}) {
         if (!sourceText.trim()) {
             return false;
         }
@@ -460,7 +475,8 @@ export function createTranslationService(deps) {
             contextUsed: false,
             id: entryId,
             translatedText: sourceText,
-            completedAt: now()
+            completedAt: now(),
+            ...metadata
         });
         pushEntry(sessionId, entry);
         return true;
@@ -550,7 +566,11 @@ export function createTranslationService(deps) {
         markFailureRetrying(sessionId, existingFailure);
         const retrying = startClaudeOutputTranslation(sessionId, original.sourceText, config, {
             entryId: original.id,
-            replaceExisting: true
+            replaceExisting: true,
+            metadata: {
+                transcriptStopReason: original.transcriptStopReason,
+                transcriptTimestamp: original.transcriptTimestamp
+            }
         });
         if (!retrying) {
             throw new VcmError({
@@ -574,6 +594,8 @@ export function createTranslationService(deps) {
             translatedText: input.translatedText ?? "",
             status: input.status,
             contextUsed: input.contextUsed,
+            transcriptStopReason: input.transcriptStopReason,
+            transcriptTimestamp: input.transcriptTimestamp,
             boundaryKind: input.boundaryKind,
             conversationTurn: input.conversationTurn,
             occurredAt: input.occurredAt,
@@ -674,6 +696,7 @@ export function createTranslationService(deps) {
             };
         },
         async pollTaskFeed(input) {
+            const config = await loadConfig();
             const cursor = Number.isFinite(input.after) ? Math.max(1, Math.floor(input.after)) : 1;
             const maxEvents = Math.min(Math.max(1, Math.floor(input.limit ?? 500)), 1000);
             const roleSessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
@@ -698,6 +721,9 @@ export function createTranslationService(deps) {
                     status: state.status
                 });
             }
+            if (config.outputMode === "round-final") {
+                await translateRoundFinalReplyIfReady(input, config);
+            }
             const feed = getTaskFeed(input.taskRepoRoot, input.taskSlug);
             const events = feed.events
                 .filter((event) => event.seq >= cursor)
@@ -1004,6 +1030,10 @@ export function createTranslationService(deps) {
         },
         async translateGatewayOutput(input) {
             const config = await loadConfig();
+            const reusable = await findReusableGatewayOutputTranslation(input, config);
+            if (reusable) {
+                return reusable.trim();
+            }
             const translation = await translateText({
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
@@ -1033,6 +1063,228 @@ export function createTranslationService(deps) {
             };
         }
     };
+    async function translateRoundFinalReplyIfReady(input, config) {
+        if (!deps.roundService || !deps.projectService) {
+            return;
+        }
+        const projectConfig = await deps.projectService.loadConfig(input.repoRoot);
+        const round = await deps.roundService.getSessionRoundState({
+            repoRoot: input.repoRoot,
+            stateRepoRoot: input.taskRepoRoot,
+            stateRoot: projectConfig.stateRoot,
+            taskSlug: input.taskSlug
+        });
+        if (!isNormalStoppedRound(round)) {
+            return;
+        }
+        const candidate = findRoundFinalReplyCandidate(input, round);
+        if (!candidate || candidate.entry.status !== "preserved") {
+            return;
+        }
+        startClaudeOutputTranslation(candidate.sessionId, candidate.entry.sourceText, config, {
+            entryId: candidate.entry.id,
+            replaceExisting: true,
+            flushImmediately: true,
+            metadata: {
+                transcriptStopReason: candidate.entry.transcriptStopReason,
+                transcriptTimestamp: candidate.entry.transcriptTimestamp
+            }
+        });
+    }
+    function isNormalStoppedRound(round) {
+        return round.status === "stopped"
+            && Boolean(round.roundId)
+            && !round.stopReason
+            && round.roleRecovery?.status !== "failed"
+            && round.flowPause?.reason !== "role-recovery-failed";
+    }
+    function findRoundFinalReplyCandidate(input, round) {
+        const candidates = [];
+        for (const [sessionId, state] of sessionStates) {
+            if (!isRoundFinalCandidateState(state, input, round.activeRole)) {
+                continue;
+            }
+            for (const entry of state.entries) {
+                if (isRoundFinalCandidateEntry(entry, input, round.stoppedAt)) {
+                    candidates.push({ sessionId, entry });
+                }
+            }
+        }
+        return candidates
+            .sort((left, right) => compareRoundFinalCandidates(left.entry, right.entry))
+            .at(-1);
+    }
+    function isRoundFinalCandidateState(state, input, activeRole) {
+        if (state.repoRoot !== input.taskRepoRoot || state.taskSlug !== input.taskSlug || !state.role) {
+            return false;
+        }
+        return !activeRole || state.role === activeRole;
+    }
+    function isRoundFinalCandidateEntry(entry, input, stoppedAt) {
+        if (entry.taskSlug !== input.taskSlug ||
+            entry.direction !== "cc-output-to-user" ||
+            entry.sourceKind !== "prose" ||
+            entry.transcriptStopReason !== "end_turn") {
+            return false;
+        }
+        if (entry.status !== "preserved" && entry.status !== "queued" && entry.status !== "translating" && entry.status !== "translated") {
+            return false;
+        }
+        if (!stoppedAt || !entry.transcriptTimestamp) {
+            return true;
+        }
+        return entry.transcriptTimestamp <= stoppedAt;
+    }
+    function compareRoundFinalCandidates(left, right) {
+        const leftTime = left.transcriptTimestamp ?? left.createdAt;
+        const rightTime = right.transcriptTimestamp ?? right.createdAt;
+        if (leftTime === rightTime) {
+            return left.id.localeCompare(right.id);
+        }
+        return leftTime.localeCompare(rightTime);
+    }
+    async function findReusableGatewayOutputTranslation(input, config) {
+        const graceDeadline = Date.now() + (input.sourceEntryIds?.length ? GATEWAY_TRANSLATION_REUSE_GRACE_MS : 0);
+        while (true) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind === "active") {
+                return waitForReusableGatewayOutputTranslation(input, config);
+            }
+            if (!input.sourceEntryIds?.length || Date.now() >= graceDeadline) {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+    }
+    async function waitForReusableGatewayOutputTranslation(input, config) {
+        const deadline = Date.now() + config.requestTimeoutMs;
+        while (Date.now() <= deadline) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind !== "active") {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+        throw new VcmError({
+            code: "TRANSLATION_TIMEOUT",
+            message: "Gateway output translation timed out while waiting for the existing PM reply translation.",
+            statusCode: 504
+        });
+    }
+    async function lookupGatewayOutputTranslation(input) {
+        const states = await getGatewayOutputCandidateStates(input);
+        return selectGatewayOutputTranslation(states, input);
+    }
+    async function getGatewayOutputCandidateStates(input) {
+        const states = [];
+        const seen = new Set();
+        const add = (state) => {
+            if (seen.has(state) || !isGatewayOutputCandidateState(state, input)) {
+                return;
+            }
+            seen.add(state);
+            states.push(state);
+        };
+        const roleSession = await getGatewayRoleSession(input);
+        if (roleSession) {
+            const state = await prepareCache({
+                repoRoot: roleSession.cwd,
+                baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            if (roleSession.status === "running") {
+                startTranscriptTail(roleSession);
+            }
+            add(state);
+        }
+        for (const state of sessionStates.values()) {
+            add(state);
+        }
+        return states;
+    }
+    async function getGatewayRoleSession(input) {
+        try {
+            return await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function isGatewayOutputCandidateState(state, input) {
+        if (state.taskSlug !== input.taskSlug || state.role !== input.role) {
+            return false;
+        }
+        return state.baseRepoRoot === input.repoRoot
+            || state.repoRoot === input.repoRoot
+            || Boolean(state.repoRoot?.startsWith(`${input.repoRoot}${path.sep}`));
+    }
+    function selectGatewayOutputTranslation(states, input) {
+        const sourceEntryIds = normalizeGatewaySourceEntryIds(input.sourceEntryIds);
+        if (sourceEntryIds.length > 0) {
+            const entries = sourceEntryIds
+                .map((entryId) => findGatewayOutputEntryById(states, input, entryId));
+            const foundEntries = entries.filter((entry) => Boolean(entry));
+            if (foundEntries.length === sourceEntryIds.length) {
+                if (foundEntries.some(isActiveTranslationEntry)) {
+                    return { kind: "active" };
+                }
+                if (foundEntries.every(isReusableGatewayOutputEntry)) {
+                    return {
+                        kind: "translated",
+                        text: foundEntries.map((entry) => entry.translatedText).join("\n\n")
+                    };
+                }
+            }
+            else if (foundEntries.some(isActiveTranslationEntry)) {
+                return { kind: "active" };
+            }
+        }
+        const normalizedSourceText = normalizeGatewaySourceText(input.text);
+        const sourceMatches = states
+            .flatMap((state) => state.entries)
+            .filter((entry) => isGatewayOutputEntry(entry, input)
+            && normalizeGatewaySourceText(entry.sourceText) === normalizedSourceText);
+        const translated = [...sourceMatches].reverse().find(isReusableGatewayOutputEntry);
+        if (translated) {
+            return { kind: "translated", text: translated.translatedText };
+        }
+        if (sourceMatches.some(isActiveTranslationEntry)) {
+            return { kind: "active" };
+        }
+        return { kind: "missing" };
+    }
+    function findGatewayOutputEntryById(states, input, entryId) {
+        for (const state of states) {
+            const entry = state.entries.find((candidate) => candidate.id === entryId && isGatewayOutputEntry(candidate, input));
+            if (entry) {
+                return entry;
+            }
+        }
+        return undefined;
+    }
+    function isGatewayOutputEntry(entry, input) {
+        return entry.taskSlug === input.taskSlug
+            && entry.role === input.role
+            && entry.direction === "cc-output-to-user"
+            && entry.sourceKind === "prose";
+    }
+    function isReusableGatewayOutputEntry(entry) {
+        return entry.status === "translated" && Boolean(entry.translatedText.trim());
+    }
+    function normalizeGatewaySourceEntryIds(sourceEntryIds) {
+        return Array.from(new Set((sourceEntryIds ?? []).map((entryId) => entryId.trim()).filter(Boolean)));
+    }
+    function normalizeGatewaySourceText(text) {
+        return text.trim();
+    }
     async function writeToCurrentRole(repoRoot, taskSlug, role, text) {
         const record = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
         if (!record || record.status !== "running") {

package/dist/shared/types/app-settings.js

@@ -12,6 +12,7 @@ export const TRANSLATION_TARGET_LANGUAGE_OPTIONS = [
     { value: "es", label: "Spanish" }
 ];
 export const TRANSLATION_OUTPUT_MODE_OPTIONS = [
+    { value: "round-final", label: "Round final reply" },
     { value: "pm-final-only", label: "PM final reply" },
     { value: "final-only", label: "Each role final reply" },
     { value: "all", label: "All replies" }